fake-bge-module 20250312__py3-none-any.whl → 20260203__py3-none-any.whl

bpy/props/__init__.pyi

@@ -10,7 +10,7 @@ All parameters to these functions must be passed as keywords.
 Custom properties can be added to any subclass of an ID,
 Bone and PoseBone.
 
-These properties can be animated, accessed by the user interface and python
+These properties can be animated, accessed by the user interface and Python
 like Blender's existing properties.
 
 [WARNING]
@@ -24,7 +24,7 @@ When accessing external non-Blender data, thread safety mechanisms should be con
 
 --------------------
 
-A common use of custom properties is for python based Operator
+A common use of custom properties is for Python based Operator
 classes. Test this code by running it in the text editor, or by clicking the
 button in the 3D View-port's Tools panel. The latter will show the properties
 in the Redo panel and allow you to change them.
@@ -69,159 +69,244 @@ of the operator, only its other properties.
 
 --------------------
 
-Getter/setter functions can be used for boolean, int, float, string and enum properties.
-If these callbacks are defined the property will not be stored in the ID properties
+Accessor functions can be used for boolean, int, float, string and enum properties.
+
+If get
+
+ or set
+
+ callbacks are defined, the property will not be stored in the ID properties
 automatically. Instead, the get
 
  and set
 
  functions will be called when the property
-is respectively read or written from the API.
+is respectively read or written from the API, and are responsible to handle the data storage.
+
+Note that:
+
+* It is illegal to define a set
+
+ callback without a matching get
+
+ one.
+* When a get
+
+ callback is defined but no set
+
+ one, the property is read-only.
+
+get_transform
+
+ and set_transform
+
+ can be used when the returned value needs to be modified,
+but the default internal storage is still used. They can only transform the value before it is
+set or returned, but do not control how/where that data is stored.
+
+[NOTE]
+It is possible to define both get
+
+/set
+
+ and get_transform
+
+/set_transform
+
+ callbacks
+for a same property. In practice however, this should rarely be needed, as most 'transform'
+operation can also happen within a get
+
+/set
+
+ callback.
 
 [WARNING]
 Remember that these callbacks may be executed in threaded context.
 
+[WARNING]
+Take care when accessing other properties in these callbacks, as it can easily trigger
+complex issues, such as infinite loops (if e.g. two properties try to also set the other
+property's value in their own set
+
+ callback), or unexpected side effects due to changes
+in data, caused e.g. by an update
+
+ callback.
+
 ```../examples/bpy.props.5.py```
 
 [NOTE]
 Pointer properties do not support storing references to embedded IDs (e.g. bpy.types.Scene.collection, bpy.types.Material.node_tree).
 These should exclusively be referenced and accessed through their owner ID (e.g. the scene or material).
 
-[NOTE]
-Typically this function doesn't need to be accessed directly.
-Instead use del cls.attr
-
-
-
 """
 
 import typing
 import collections.abc
 import typing_extensions
-import bpy._typing.rna_enums
+import numpy.typing as npt
+import bpy.stub_internal.rna_enums
 import bpy.types
 
-def BoolProperty(
+def BoolProperty[_GenericType1: bpy.types.bpy_struct](
     *,
     name: str | None = "",
     description: str | None = "",
     translation_context: str | None = "*",
     default=False,
-    options: set[bpy._typing.rna_enums.PropertyFlagItems] = {"ANIMATABLE"},
-    override: set[bpy._typing.rna_enums.PropertyOverrideFlagItems] = set(),
-    tags=set(),
-    subtype: bpy._typing.rna_enums.PropertySubtypeNumberItems = "NONE",
-    update: collections.abc.Callable[[bpy.types.bpy_struct, bpy.types.Context], None]
+    options: set[bpy.stub_internal.rna_enums.PropertyFlagItems] = {"ANIMATABLE"},
+    override: set[bpy.stub_internal.rna_enums.PropertyOverrideFlagItems] = set(),
+    tags: set[str] | None = set(),
+    subtype: bpy.stub_internal.rna_enums.PropertySubtypeNumberItems = "NONE",
+    update: collections.abc.Callable[[_GenericType1, bpy.types.Context], None]
+    | None = None,
+    get: collections.abc.Callable[[_GenericType1], bool] | None = None,
+    set: collections.abc.Callable[[_GenericType1, bool], None] | None = None,
+    get_transform: collections.abc.Callable[[bpy.types.bpy_struct, bool, bool], bool]
+    | None = None,
+    set_transform: collections.abc.Callable[
+        [bpy.types.bpy_struct, bool, bool, bool], bool
+    ]
     | None = None,
-    get: collections.abc.Callable[[bpy.types.bpy_struct], bool] | None = None,
-    set: collections.abc.Callable[[bpy.types.bpy_struct, bool], None] | None = None,
-):
+) -> None:
     """Returns a new boolean property definition.
 
         :param name: Name used in the user interface.
-        :type name: str | None
         :param description: Text used for the tooltip and api documentation.
-        :type description: str | None
         :param translation_context: Text used as context to disambiguate translations.
-        :type translation_context: str | None
         :param options: Enumerator in `rna_enum_property_flag_items`.
-        :type options: set[bpy._typing.rna_enums.PropertyFlagItems]
         :param override: Enumerator in `rna_enum_property_override_flag_items`.
-        :type override: set[bpy._typing.rna_enums.PropertyOverrideFlagItems]
         :param tags: Enumerator of tags that are defined by parent class.
         :param subtype: Enumerator in `rna_enum_property_subtype_number_items`.
-        :type subtype: bpy._typing.rna_enums.PropertySubtypeNumberItems
         :param update: Function to be called when this value is modified,
     This function must take 2 values (self, context) and return None.
     Warning there are no safety checks to avoid infinite recursion.
-        :type update: collections.abc.Callable[[bpy.types.bpy_struct, bpy.types.Context], None] | None
-        :param get: Function to be called when this value is 'read',
+        :param get: Function to be called when this value is read, and the default,
+    system-defined storage is not used for this property.
     This function must take 1 value (self) and return the value of the property.
-        :type get: collections.abc.Callable[[bpy.types.bpy_struct], bool] | None
-        :param set: Function to be called when this value is 'written',
+
+    Defining this callback without a matching set one will make the property read-only (even if READ_ONLY option is not set).
+        :param set: Function to be called when this value is written, and the default,
+    system-defined storage is not used for this property.
     This function must take 2 values (self, value) and return None.
-        :type set: collections.abc.Callable[[bpy.types.bpy_struct, bool], None] | None
+
+    Defining this callback without a matching get one is invalid.
+        :param get_transform: Function to be called when this value is read,
+    if some additional processing must be performed on the stored value.
+    This function must take three arguments (self, the stored value,
+    and a boolean indicating if the property is currently set),
+    and return the final, transformed value of the property.
+
+    The callback is responsible to ensure that value limits of the property (min/max, length...) are respected. Otherwise a ValueError exception is raised.
+        :param set_transform: Function to be called when this value is written,
+    if some additional processing must be performed on the given value before storing it.
+    This function must take four arguments (self, the given value to store,
+    the currently stored value (raw value, without any get_transform applied to it),
+    and a boolean indicating if the property is currently set),
+    and return the final, transformed value of the property.
+
+    The callback is responsible to ensure that value limits (min/max, length...) are respected. Otherwise a ValueError exception is raised.
     """
 
-def BoolVectorProperty(
+def BoolVectorProperty[_GenericType1: bpy.types.bpy_struct](
     *,
     name: str | None = "",
     description: str | None = "",
     translation_context: str | None = "*",
     default: collections.abc.Sequence[bool] | None = (False, False, False),
-    options: set[bpy._typing.rna_enums.PropertyFlagItems] = {"ANIMATABLE"},
-    override: set[bpy._typing.rna_enums.PropertyOverrideFlagItems] = set(),
-    tags=set(),
-    subtype: bpy._typing.rna_enums.PropertySubtypeNumberArrayItems = "NONE",
+    options: set[bpy.stub_internal.rna_enums.PropertyFlagItems] = {"ANIMATABLE"},
+    override: set[bpy.stub_internal.rna_enums.PropertyOverrideFlagItems] = set(),
+    tags: set[str] | None = set(),
+    subtype: bpy.stub_internal.rna_enums.PropertySubtypeNumberArrayItems = "NONE",
     size: collections.abc.Sequence[int] | int | None = 3,
-    update: collections.abc.Callable[[bpy.types.bpy_struct, bpy.types.Context], None]
+    update: collections.abc.Callable[[_GenericType1, bpy.types.Context], None]
+    | None = None,
+    get: collections.abc.Callable[[_GenericType1], collections.abc.Sequence[bool]]
     | None = None,
-    get: collections.abc.Callable[
-        [bpy.types.bpy_struct], collections.abc.Sequence[bool]
+    set: collections.abc.Callable[[_GenericType1, collections.abc.Sequence[bool]], None]
+    | None = None,
+    get_transform: collections.abc.Callable[
+        [bpy.types.bpy_struct, collections.abc.Sequence[bool], bool],
+        collections.abc.Sequence[bool],
     ]
     | None = None,
-    set: collections.abc.Callable[[bpy.types.bpy_struct, tuple[bool, ...]], None]
+    set_transform: collections.abc.Callable[
+        [
+            bpy.types.bpy_struct,
+            collections.abc.Sequence[bool],
+            collections.abc.Sequence[bool],
+            bool,
+        ],
+        collections.abc.Sequence[bool],
+    ]
     | None = None,
-):
+) -> None:
     """Returns a new vector boolean property definition.
 
         :param name: Name used in the user interface.
-        :type name: str | None
         :param description: Text used for the tooltip and api documentation.
-        :type description: str | None
         :param translation_context: Text used as context to disambiguate translations.
-        :type translation_context: str | None
         :param default: sequence of booleans the length of size.
-        :type default: collections.abc.Sequence[bool] | None
         :param options: Enumerator in `rna_enum_property_flag_items`.
-        :type options: set[bpy._typing.rna_enums.PropertyFlagItems]
         :param override: Enumerator in `rna_enum_property_override_flag_items`.
-        :type override: set[bpy._typing.rna_enums.PropertyOverrideFlagItems]
         :param tags: Enumerator of tags that are defined by parent class.
         :param subtype: Enumerator in `rna_enum_property_subtype_number_array_items`.
-        :type subtype: bpy._typing.rna_enums.PropertySubtypeNumberArrayItems
         :param size: Vector dimensions in [1, 32]. An int sequence can be used to define multi-dimension arrays.
-        :type size: collections.abc.Sequence[int] | int | None
         :param update: Function to be called when this value is modified,
     This function must take 2 values (self, context) and return None.
     Warning there are no safety checks to avoid infinite recursion.
-        :type update: collections.abc.Callable[[bpy.types.bpy_struct, bpy.types.Context], None] | None
-        :param get: Function to be called when this value is 'read',
+        :param get: Function to be called when this value is read, and the default,
+    system-defined storage is not used for this property.
     This function must take 1 value (self) and return the value of the property.
-        :type get: collections.abc.Callable[[bpy.types.bpy_struct], collections.abc.Sequence[bool]] | None
-        :param set: Function to be called when this value is 'written',
+
+    Defining this callback without a matching set one will make the property read-only (even if READ_ONLY option is not set).
+        :param set: Function to be called when this value is written, and the default,
+    system-defined storage is not used for this property.
     This function must take 2 values (self, value) and return None.
-        :type set: collections.abc.Callable[[bpy.types.bpy_struct, tuple[bool, ...]], None] | None
+
+    Defining this callback without a matching get one is invalid.
+        :param get_transform: Function to be called when this value is read,
+    if some additional processing must be performed on the stored value.
+    This function must take three arguments (self, the stored value,
+    and a boolean indicating if the property is currently set),
+    and return the final, transformed value of the property.
+
+    The callback is responsible to ensure that value limits of the property (min/max, length...) are respected. Otherwise a ValueError exception is raised.
+        :param set_transform: Function to be called when this value is written,
+    if some additional processing must be performed on the given value before storing it.
+    This function must take four arguments (self, the given value to store,
+    the currently stored value (raw value, without any get_transform applied to it),
+    and a boolean indicating if the property is currently set),
+    and return the final, transformed value of the property.
+
+    The callback is responsible to ensure that value limits (min/max, length...) are respected. Otherwise a ValueError exception is raised.
     """
 
 def CollectionProperty(
     *,
-    type: type[bpy.types.PropertyGroup] | None = None,
+    type: type[bpy.types.PropertyGroup] | None,
     name: str | None = "",
     description: str | None = "",
     translation_context: str | None = "*",
-    options: set[bpy._typing.rna_enums.PropertyFlagItems] = {"ANIMATABLE"},
-    override: set[bpy._typing.rna_enums.PropertyOverrideFlagCollectionItems] = set(),
-    tags=set(),
-):
+    options: set[bpy.stub_internal.rna_enums.PropertyFlagItems] = {"ANIMATABLE"},
+    override: set[
+        bpy.stub_internal.rna_enums.PropertyOverrideFlagCollectionItems
+    ] = set(),
+    tags: set[str] | None = set(),
+) -> None:
     """Returns a new collection property definition.
 
     :param type: A subclass of a property group.
-    :type type: type[bpy.types.PropertyGroup] | None
     :param name: Name used in the user interface.
-    :type name: str | None
     :param description: Text used for the tooltip and api documentation.
-    :type description: str | None
     :param translation_context: Text used as context to disambiguate translations.
-    :type translation_context: str | None
     :param options: Enumerator in `rna_enum_property_flag_items`.
-    :type options: set[bpy._typing.rna_enums.PropertyFlagItems]
     :param override: Enumerator in `rna_enum_property_override_flag_collection_items`.
-    :type override: set[bpy._typing.rna_enums.PropertyOverrideFlagCollectionItems]
     :param tags: Enumerator of tags that are defined by parent class.
     """
 
-def EnumProperty(
+def EnumProperty[_GenericType1: bpy.types.bpy_struct](
     *,
     items: collections.abc.Iterable[
         tuple[str, str, str]
@@ -230,7 +315,7 @@ def EnumProperty(
         | None
     ]
     | collections.abc.Callable[
-        [typing.Any, bpy.types.Context | None],
+        [_GenericType1, bpy.types.Context | None],
         collections.abc.Iterable[
             tuple[str, str, str]
             | tuple[str, str, str, int]
@@ -241,15 +326,19 @@ def EnumProperty(
     name: str | None = "",
     description: str | None = "",
     translation_context: str | None = "*",
-    default: int | str | None = None,
-    options: set[bpy._typing.rna_enums.PropertyFlagEnumItems] = {"ANIMATABLE"},
-    override: set[bpy._typing.rna_enums.PropertyOverrideFlagItems] = set(),
-    tags=set(),
-    update: collections.abc.Callable[[bpy.types.bpy_struct, bpy.types.Context], None]
+    default: int | set[str] | str | None = None,
+    options: set[bpy.stub_internal.rna_enums.PropertyFlagEnumItems] = {"ANIMATABLE"},
+    override: set[bpy.stub_internal.rna_enums.PropertyOverrideFlagItems] = set(),
+    tags: set[str] | None = set(),
+    update: collections.abc.Callable[[_GenericType1, bpy.types.Context], None]
     | None = None,
-    get: collections.abc.Callable[[bpy.types.bpy_struct], int] | None = None,
-    set: collections.abc.Callable[[bpy.types.bpy_struct, int], None] | None = None,
-):
+    get: collections.abc.Callable[[_GenericType1], int] | None = None,
+    set: collections.abc.Callable[[_GenericType1, int], None] | None = None,
+    get_transform: collections.abc.Callable[[bpy.types.bpy_struct, int, bool], int]
+    | None = None,
+    set_transform: collections.abc.Callable[[bpy.types.bpy_struct, int, int, bool], int]
+    | None = None,
+) -> None:
     """Returns a new enumerator property definition.
 
         :param items: sequence of enum items formatted:
@@ -293,36 +382,47 @@ def EnumProperty(
     There is a known bug with using a callback,
     Python must keep a reference to the strings returned by the callback or Blender
     will misbehave or even crash.
-        :type items: collections.abc.Iterable[tuple[str, str, str] | tuple[str, str, str, int] | tuple[str, str, str, str, int] | None] | collections.abc.Callable[[typing.Any, bpy.types.Context | None], collections.abc.Iterable[tuple[str, str, str] | tuple[str, str, str, int] | tuple[str, str, str, str, int] | None]]
         :param name: Name used in the user interface.
-        :type name: str | None
         :param description: Text used for the tooltip and api documentation.
-        :type description: str | None
         :param translation_context: Text used as context to disambiguate translations.
-        :type translation_context: str | None
         :param default: The default value for this enum, a string from the identifiers used in items, or integer matching an item number.
     If the ENUM_FLAG option is used this must be a set of such string identifiers instead.
     WARNING: Strings cannot be specified for dynamic enums
     (i.e. if a callback function is given as items parameter).
-        :type default: int | str | None
         :param options: Enumerator in `rna_enum_property_flag_enum_items`.
-        :type options: set[bpy._typing.rna_enums.PropertyFlagEnumItems]
         :param override: Enumerator in `rna_enum_property_override_flag_items`.
-        :type override: set[bpy._typing.rna_enums.PropertyOverrideFlagItems]
         :param tags: Enumerator of tags that are defined by parent class.
         :param update: Function to be called when this value is modified,
     This function must take 2 values (self, context) and return None.
     Warning there are no safety checks to avoid infinite recursion.
-        :type update: collections.abc.Callable[[bpy.types.bpy_struct, bpy.types.Context], None] | None
-        :param get: Function to be called when this value is 'read',
+        :param get: Function to be called when this value is read, and the default,
+    system-defined storage is not used for this property.
     This function must take 1 value (self) and return the value of the property.
-        :type get: collections.abc.Callable[[bpy.types.bpy_struct], int] | None
-        :param set: Function to be called when this value is 'written',
+
+    Defining this callback without a matching set one will make the property read-only (even if READ_ONLY option is not set).
+        :param set: Function to be called when this value is written, and the default,
+    system-defined storage is not used for this property.
     This function must take 2 values (self, value) and return None.
-        :type set: collections.abc.Callable[[bpy.types.bpy_struct, int], None] | None
+
+    Defining this callback without a matching get one is invalid.
+        :param get_transform: Function to be called when this value is read,
+    if some additional processing must be performed on the stored value.
+    This function must take three arguments (self, the stored value,
+    and a boolean indicating if the property is currently set),
+    and return the final, transformed value of the property.
+
+    The callback is responsible to ensure that value limits of the property (min/max, length...) are respected. Otherwise a ValueError exception is raised.
+        :param set_transform: Function to be called when this value is written,
+    if some additional processing must be performed on the given value before storing it.
+    This function must take four arguments (self, the given value to store,
+    the currently stored value (raw value, without any get_transform applied to it),
+    and a boolean indicating if the property is currently set),
+    and return the final, transformed value of the property.
+
+    The callback is responsible to ensure that value limits (min/max, length...) are respected. Otherwise a ValueError exception is raised.
     """
 
-def FloatProperty(
+def FloatProperty[_GenericType1: bpy.types.bpy_struct](
     *,
     name: str | None = "",
     description: str | None = "",
@@ -332,60 +432,71 @@ def FloatProperty(
     max: float | None = 3.402823e38,
     soft_min: float | None = -3.402823e38,
     soft_max: float | None = 3.402823e38,
-    step: int | None = 3,
+    step: float | None = 3,
     precision: int | None = 2,
-    options: set[bpy._typing.rna_enums.PropertyFlagItems] = {"ANIMATABLE"},
-    override: set[bpy._typing.rna_enums.PropertyOverrideFlagItems] = set(),
-    tags=set(),
-    subtype: bpy._typing.rna_enums.PropertySubtypeNumberItems = "NONE",
-    unit: bpy._typing.rna_enums.PropertyUnitItems = "NONE",
-    update: collections.abc.Callable[[bpy.types.bpy_struct, bpy.types.Context], None]
+    options: set[bpy.stub_internal.rna_enums.PropertyFlagItems] = {"ANIMATABLE"},
+    override: set[bpy.stub_internal.rna_enums.PropertyOverrideFlagItems] = set(),
+    tags: set[str] | None = set(),
+    subtype: bpy.stub_internal.rna_enums.PropertySubtypeNumberItems = "NONE",
+    unit: bpy.stub_internal.rna_enums.PropertyUnitItems = "NONE",
+    update: collections.abc.Callable[[_GenericType1, bpy.types.Context], None]
     | None = None,
-    get: collections.abc.Callable[[bpy.types.bpy_struct], float] | None = None,
-    set: collections.abc.Callable[[bpy.types.bpy_struct, float], None] | None = None,
-):
+    get: collections.abc.Callable[[_GenericType1], float] | None = None,
+    set: collections.abc.Callable[[_GenericType1, float], None] | None = None,
+    get_transform: collections.abc.Callable[[bpy.types.bpy_struct, float, bool], float]
+    | None = None,
+    set_transform: collections.abc.Callable[
+        [bpy.types.bpy_struct, float, float, bool], float
+    ]
+    | None = None,
+) -> None:
     """Returns a new float (single precision) property definition.
 
         :param name: Name used in the user interface.
-        :type name: str | None
         :param description: Text used for the tooltip and api documentation.
-        :type description: str | None
         :param translation_context: Text used as context to disambiguate translations.
-        :type translation_context: str | None
         :param min: Hard minimum, trying to assign a value below will silently assign this minimum instead.
-        :type min: float | None
         :param max: Hard maximum, trying to assign a value above will silently assign this maximum instead.
-        :type max: float | None
-        :param soft_min: Soft minimum (>= min), user won't be able to drag the widget below this value in the UI.
-        :type soft_min: float | None
-        :param soft_max: Soft maximum (<= max), user won't be able to drag the widget above this value in the UI.
-        :type soft_max: float | None
+        :param soft_min: Soft minimum (>= min), user wont be able to drag the widget below this value in the UI.
+        :param soft_max: Soft maximum (<= max), user wont be able to drag the widget above this value in the UI.
         :param step: Step of increment/decrement in UI, in [1, 100], defaults to 3 (WARNING: actual value is /100).
-        :type step: int | None
-        :param precision: Maximum number of decimal digits to display, in [0, 6]. Fraction is automatically hidden for exact integer values of fields with unit 'NONE' or 'TIME' (frame count) and step divisible by 100.
-        :type precision: int | None
+        :param precision: Maximum number of decimal digits to display, in [0, 6]. Fraction is automatically hidden for exact integer values of fields with unit NONE or TIME (frame count) and step divisible by 100.
         :param options: Enumerator in `rna_enum_property_flag_items`.
-        :type options: set[bpy._typing.rna_enums.PropertyFlagItems]
         :param override: Enumerator in `rna_enum_property_override_flag_items`.
-        :type override: set[bpy._typing.rna_enums.PropertyOverrideFlagItems]
         :param tags: Enumerator of tags that are defined by parent class.
         :param subtype: Enumerator in `rna_enum_property_subtype_number_items`.
-        :type subtype: bpy._typing.rna_enums.PropertySubtypeNumberItems
         :param unit: Enumerator in `rna_enum_property_unit_items`.
-        :type unit: bpy._typing.rna_enums.PropertyUnitItems
         :param update: Function to be called when this value is modified,
     This function must take 2 values (self, context) and return None.
     Warning there are no safety checks to avoid infinite recursion.
-        :type update: collections.abc.Callable[[bpy.types.bpy_struct, bpy.types.Context], None] | None
-        :param get: Function to be called when this value is 'read',
+        :param get: Function to be called when this value is read, and the default,
+    system-defined storage is not used for this property.
     This function must take 1 value (self) and return the value of the property.
-        :type get: collections.abc.Callable[[bpy.types.bpy_struct], float] | None
-        :param set: Function to be called when this value is 'written',
+
+    Defining this callback without a matching set one will make the property read-only (even if READ_ONLY option is not set).
+        :param set: Function to be called when this value is written, and the default,
+    system-defined storage is not used for this property.
     This function must take 2 values (self, value) and return None.
-        :type set: collections.abc.Callable[[bpy.types.bpy_struct, float], None] | None
+
+    Defining this callback without a matching get one is invalid.
+        :param get_transform: Function to be called when this value is read,
+    if some additional processing must be performed on the stored value.
+    This function must take three arguments (self, the stored value,
+    and a boolean indicating if the property is currently set),
+    and return the final, transformed value of the property.
+
+    The callback is responsible to ensure that value limits of the property (min/max, length...) are respected. Otherwise a ValueError exception is raised.
+        :param set_transform: Function to be called when this value is written,
+    if some additional processing must be performed on the given value before storing it.
+    This function must take four arguments (self, the given value to store,
+    the currently stored value (raw value, without any get_transform applied to it),
+    and a boolean indicating if the property is currently set),
+    and return the final, transformed value of the property.
+
+    The callback is responsible to ensure that value limits (min/max, length...) are respected. Otherwise a ValueError exception is raised.
     """
 
-def FloatVectorProperty(
+def FloatVectorProperty[_GenericType1: bpy.types.bpy_struct](
     *,
     name: str | None = "",
     description: str | None = "",
@@ -395,69 +506,57 @@ def FloatVectorProperty(
     max: float | None = sys.float_info.max,
     soft_min: float | None = sys.float_info.min,
     soft_max: float | None = sys.float_info.max,
-    step: int | None = 3,
+    step: float | None = 3,
     precision: int | None = 2,
-    options: set[bpy._typing.rna_enums.PropertyFlagItems] = {"ANIMATABLE"},
-    override: set[bpy._typing.rna_enums.PropertyOverrideFlagItems] = set(),
-    tags=set(),
-    subtype: bpy._typing.rna_enums.PropertySubtypeNumberArrayItems = "NONE",
-    unit: bpy._typing.rna_enums.PropertyUnitItems = "NONE",
+    options: set[bpy.stub_internal.rna_enums.PropertyFlagItems] = {"ANIMATABLE"},
+    override: set[bpy.stub_internal.rna_enums.PropertyOverrideFlagItems] = set(),
+    tags: set[str] | None = set(),
+    subtype: bpy.stub_internal.rna_enums.PropertySubtypeNumberArrayItems = "NONE",
+    unit: bpy.stub_internal.rna_enums.PropertyUnitItems = "NONE",
     size: collections.abc.Sequence[int] | int | None = 3,
-    update: collections.abc.Callable[[bpy.types.bpy_struct, bpy.types.Context], None]
+    update: collections.abc.Callable[[_GenericType1, bpy.types.Context], None]
     | None = None,
-    get: collections.abc.Callable[
-        [bpy.types.bpy_struct], collections.abc.Sequence[float]
-    ]
+    get: collections.abc.Callable[[_GenericType1], collections.abc.Sequence[float]]
     | None = None,
-    set: collections.abc.Callable[[bpy.types.bpy_struct, tuple[float, ...]], None]
+    set: collections.abc.Callable[
+        [_GenericType1, collections.abc.Sequence[float]], None
+    ]
     | None = None,
-):
+) -> None:
     """Returns a new vector float property definition.
 
         :param name: Name used in the user interface.
-        :type name: str | None
         :param description: Text used for the tooltip and api documentation.
-        :type description: str | None
         :param translation_context: Text used as context to disambiguate translations.
-        :type translation_context: str | None
         :param default: Sequence of floats the length of size.
-        :type default: collections.abc.Sequence[float] | None
         :param min: Hard minimum, trying to assign a value below will silently assign this minimum instead.
-        :type min: float | None
         :param max: Hard maximum, trying to assign a value above will silently assign this maximum instead.
-        :type max: float | None
-        :param soft_min: Soft minimum (>= min), user won't be able to drag the widget below this value in the UI.
-        :type soft_min: float | None
-        :param soft_max: Soft maximum (<= max), user won't be able to drag the widget above this value in the UI.
-        :type soft_max: float | None
+        :param soft_min: Soft minimum (>= min), user wont be able to drag the widget below this value in the UI.
+        :param soft_max: Soft maximum (<= max), user wont be able to drag the widget above this value in the UI.
         :param step: Step of increment/decrement in UI, in [1, 100], defaults to 3 (WARNING: actual value is /100).
-        :type step: int | None
-        :param precision: Maximum number of decimal digits to display, in [0, 6]. Fraction is automatically hidden for exact integer values of fields with unit 'NONE' or 'TIME' (frame count) and step divisible by 100.
-        :type precision: int | None
+        :param precision: Maximum number of decimal digits to display, in [0, 6]. Fraction is automatically hidden for exact integer values of fields with unit NONE or TIME (frame count) and step divisible by 100.
         :param options: Enumerator in `rna_enum_property_flag_items`.
-        :type options: set[bpy._typing.rna_enums.PropertyFlagItems]
         :param override: Enumerator in `rna_enum_property_override_flag_items`.
-        :type override: set[bpy._typing.rna_enums.PropertyOverrideFlagItems]
         :param tags: Enumerator of tags that are defined by parent class.
         :param subtype: Enumerator in `rna_enum_property_subtype_number_array_items`.
-        :type subtype: bpy._typing.rna_enums.PropertySubtypeNumberArrayItems
         :param unit: Enumerator in `rna_enum_property_unit_items`.
-        :type unit: bpy._typing.rna_enums.PropertyUnitItems
         :param size: Vector dimensions in [1, 32]. An int sequence can be used to define multi-dimension arrays.
-        :type size: collections.abc.Sequence[int] | int | None
         :param update: Function to be called when this value is modified,
     This function must take 2 values (self, context) and return None.
     Warning there are no safety checks to avoid infinite recursion.
-        :type update: collections.abc.Callable[[bpy.types.bpy_struct, bpy.types.Context], None] | None
-        :param get: Function to be called when this value is 'read',
+        :param get: Function to be called when this value is read, and the default,
+    system-defined storage is not used for this property.
     This function must take 1 value (self) and return the value of the property.
-        :type get: collections.abc.Callable[[bpy.types.bpy_struct], collections.abc.Sequence[float]] | None
-        :param set: Function to be called when this value is 'written',
+
+    Defining this callback without a matching set one will make the property read-only (even if READ_ONLY option is not set).
+        :param set: Function to be called when this value is written, and the default,
+    system-defined storage is not used for this property.
     This function must take 2 values (self, value) and return None.
-        :type set: collections.abc.Callable[[bpy.types.bpy_struct, tuple[float, ...]], None] | None
+
+    Defining this callback without a matching get one is invalid.
     """
 
-def IntProperty(
+def IntProperty[_GenericType1: bpy.types.bpy_struct](
     *,
     name: str | None = "",
     description: str | None = "",
@@ -468,53 +567,64 @@ def IntProperty(
     soft_min: int | None = None,
     soft_max: int | None = None,
     step: int | None = 1,
-    options: set[bpy._typing.rna_enums.PropertyFlagItems] = {"ANIMATABLE"},
-    override: set[bpy._typing.rna_enums.PropertyOverrideFlagItems] = set(),
-    tags=set(),
-    subtype: bpy._typing.rna_enums.PropertySubtypeNumberItems = "NONE",
-    update: collections.abc.Callable[[bpy.types.bpy_struct, bpy.types.Context], None]
+    options: set[bpy.stub_internal.rna_enums.PropertyFlagItems] = {"ANIMATABLE"},
+    override: set[bpy.stub_internal.rna_enums.PropertyOverrideFlagItems] = set(),
+    tags: set[str] | None = set(),
+    subtype: bpy.stub_internal.rna_enums.PropertySubtypeNumberItems = "NONE",
+    update: collections.abc.Callable[[_GenericType1, bpy.types.Context], None]
+    | None = None,
+    get: collections.abc.Callable[[_GenericType1], int] | None = None,
+    set: collections.abc.Callable[[_GenericType1, int], None] | None = None,
+    get_transform: collections.abc.Callable[[bpy.types.bpy_struct, int, bool], int]
+    | None = None,
+    set_transform: collections.abc.Callable[[bpy.types.bpy_struct, int, int, bool], int]
     | None = None,
-    get: collections.abc.Callable[[bpy.types.bpy_struct], int] | None = None,
-    set: collections.abc.Callable[[bpy.types.bpy_struct, int], None] | None = None,
-):
+) -> None:
     """Returns a new int property definition.
 
         :param name: Name used in the user interface.
-        :type name: str | None
         :param description: Text used for the tooltip and api documentation.
-        :type description: str | None
         :param translation_context: Text used as context to disambiguate translations.
-        :type translation_context: str | None
         :param min: Hard minimum, trying to assign a value below will silently assign this minimum instead.
-        :type min: int | None
         :param max: Hard maximum, trying to assign a value above will silently assign this maximum instead.
-        :type max: int | None
-        :param soft_min: Soft minimum (>= min), user won't be able to drag the widget below this value in the UI.
-        :type soft_min: int | None
-        :param soft_max: Soft maximum (<= max), user won't be able to drag the widget above this value in the UI.
-        :type soft_max: int | None
+        :param soft_min: Soft minimum (>= min), user wont be able to drag the widget below this value in the UI.
+        :param soft_max: Soft maximum (<= max), user wont be able to drag the widget above this value in the UI.
         :param step: Step of increment/decrement in UI, in [1, 100], defaults to 1 (WARNING: unused currently!).
-        :type step: int | None
         :param options: Enumerator in `rna_enum_property_flag_items`.
-        :type options: set[bpy._typing.rna_enums.PropertyFlagItems]
         :param override: Enumerator in `rna_enum_property_override_flag_items`.
-        :type override: set[bpy._typing.rna_enums.PropertyOverrideFlagItems]
         :param tags: Enumerator of tags that are defined by parent class.
         :param subtype: Enumerator in `rna_enum_property_subtype_number_items`.
-        :type subtype: bpy._typing.rna_enums.PropertySubtypeNumberItems
         :param update: Function to be called when this value is modified,
     This function must take 2 values (self, context) and return None.
     Warning there are no safety checks to avoid infinite recursion.
-        :type update: collections.abc.Callable[[bpy.types.bpy_struct, bpy.types.Context], None] | None
-        :param get: Function to be called when this value is 'read',
+        :param get: Function to be called when this value is read, and the default,
+    system-defined storage is not used for this property.
     This function must take 1 value (self) and return the value of the property.
-        :type get: collections.abc.Callable[[bpy.types.bpy_struct], int] | None
-        :param set: Function to be called when this value is 'written',
+
+    Defining this callback without a matching set one will make the property read-only (even if READ_ONLY option is not set).
+        :param set: Function to be called when this value is written, and the default,
+    system-defined storage is not used for this property.
     This function must take 2 values (self, value) and return None.
-        :type set: collections.abc.Callable[[bpy.types.bpy_struct, int], None] | None
+
+    Defining this callback without a matching get one is invalid.
+        :param get_transform: Function to be called when this value is read,
+    if some additional processing must be performed on the stored value.
+    This function must take three arguments (self, the stored value,
+    and a boolean indicating if the property is currently set),
+    and return the final, transformed value of the property.
+
+    The callback is responsible to ensure that value limits of the property (min/max, length...) are respected. Otherwise a ValueError exception is raised.
+        :param set_transform: Function to be called when this value is written,
+    if some additional processing must be performed on the given value before storing it.
+    This function must take four arguments (self, the given value to store,
+    the currently stored value (raw value, without any get_transform applied to it),
+    and a boolean indicating if the property is currently set),
+    and return the final, transformed value of the property.
+
+    The callback is responsible to ensure that value limits (min/max, length...) are respected. Otherwise a ValueError exception is raised.
     """
 
-def IntVectorProperty(
+def IntVectorProperty[_GenericType1: bpy.types.bpy_struct](
     *,
     name: str | None = "",
     description: str | None = "",
@@ -525,156 +635,183 @@ def IntVectorProperty(
     soft_min: int | None = None,
     soft_max: int | None = None,
     step: int | None = 1,
-    options: set[bpy._typing.rna_enums.PropertyFlagItems] = {"ANIMATABLE"},
-    override: set[bpy._typing.rna_enums.PropertyOverrideFlagItems] = set(),
-    tags=set(),
-    subtype: bpy._typing.rna_enums.PropertySubtypeNumberArrayItems = "NONE",
+    options: set[bpy.stub_internal.rna_enums.PropertyFlagItems] = {"ANIMATABLE"},
+    override: set[bpy.stub_internal.rna_enums.PropertyOverrideFlagItems] = set(),
+    tags: set[str] | None = set(),
+    subtype: bpy.stub_internal.rna_enums.PropertySubtypeNumberArrayItems = "NONE",
     size: collections.abc.Sequence[int] | int | None = 3,
-    update: collections.abc.Callable[[bpy.types.bpy_struct, bpy.types.Context], None]
+    update: collections.abc.Callable[[_GenericType1, bpy.types.Context], None]
     | None = None,
-    get: collections.abc.Callable[[bpy.types.bpy_struct], collections.abc.Sequence[int]]
+    get: collections.abc.Callable[[_GenericType1], collections.abc.Sequence[int]]
     | None = None,
-    set: collections.abc.Callable[[bpy.types.bpy_struct, tuple[int, ...]], None]
+    set: collections.abc.Callable[[_GenericType1, collections.abc.Sequence[int]], None]
     | None = None,
-):
+    get_transform: collections.abc.Callable[
+        [bpy.types.bpy_struct, collections.abc.Sequence[int], bool],
+        collections.abc.Sequence[int],
+    ]
+    | None = None,
+    set_transform: collections.abc.Callable[
+        [
+            bpy.types.bpy_struct,
+            collections.abc.Sequence[int],
+            collections.abc.Sequence[int],
+            bool,
+        ],
+        collections.abc.Sequence[int],
+    ]
+    | None = None,
+) -> None:
     """Returns a new vector int property definition.
 
         :param name: Name used in the user interface.
-        :type name: str | None
         :param description: Text used for the tooltip and api documentation.
-        :type description: str | None
         :param translation_context: Text used as context to disambiguate translations.
-        :type translation_context: str | None
         :param default: sequence of ints the length of size.
-        :type default: collections.abc.Sequence[int] | None
         :param min: Hard minimum, trying to assign a value below will silently assign this minimum instead.
-        :type min: int | None
         :param max: Hard maximum, trying to assign a value above will silently assign this maximum instead.
-        :type max: int | None
-        :param soft_min: Soft minimum (>= min), user won't be able to drag the widget below this value in the UI.
-        :type soft_min: int | None
-        :param soft_max: Soft maximum (<= max), user won't be able to drag the widget above this value in the UI.
-        :type soft_max: int | None
+        :param soft_min: Soft minimum (>= min), user wont be able to drag the widget below this value in the UI.
+        :param soft_max: Soft maximum (<= max), user wont be able to drag the widget above this value in the UI.
         :param step: Step of increment/decrement in UI, in [1, 100], defaults to 1 (WARNING: unused currently!).
-        :type step: int | None
         :param options: Enumerator in `rna_enum_property_flag_items`.
-        :type options: set[bpy._typing.rna_enums.PropertyFlagItems]
         :param override: Enumerator in `rna_enum_property_override_flag_items`.
-        :type override: set[bpy._typing.rna_enums.PropertyOverrideFlagItems]
         :param tags: Enumerator of tags that are defined by parent class.
         :param subtype: Enumerator in `rna_enum_property_subtype_number_array_items`.
-        :type subtype: bpy._typing.rna_enums.PropertySubtypeNumberArrayItems
         :param size: Vector dimensions in [1, 32]. An int sequence can be used to define multi-dimension arrays.
-        :type size: collections.abc.Sequence[int] | int | None
         :param update: Function to be called when this value is modified,
     This function must take 2 values (self, context) and return None.
     Warning there are no safety checks to avoid infinite recursion.
-        :type update: collections.abc.Callable[[bpy.types.bpy_struct, bpy.types.Context], None] | None
-        :param get: Function to be called when this value is 'read',
+        :param get: Function to be called when this value is read, and the default,
+    system-defined storage is not used for this property.
     This function must take 1 value (self) and return the value of the property.
-        :type get: collections.abc.Callable[[bpy.types.bpy_struct], collections.abc.Sequence[int]] | None
-        :param set: Function to be called when this value is 'written',
+
+    Defining this callback without a matching set one will make the property read-only (even if READ_ONLY option is not set).
+        :param set: Function to be called when this value is written, and the default,
+    system-defined storage is not used for this property.
     This function must take 2 values (self, value) and return None.
-        :type set: collections.abc.Callable[[bpy.types.bpy_struct, tuple[int, ...]], None] | None
+
+    Defining this callback without a matching get one is invalid.
+        :param get_transform: Function to be called when this value is read,
+    if some additional processing must be performed on the stored value.
+    This function must take three arguments (self, the stored value,
+    and a boolean indicating if the property is currently set),
+    and return the final, transformed value of the property.
+
+    The callback is responsible to ensure that value limits of the property (min/max, length...) are respected. Otherwise a ValueError exception is raised.
+        :param set_transform: Function to be called when this value is written,
+    if some additional processing must be performed on the given value before storing it.
+    This function must take four arguments (self, the given value to store,
+    the currently stored value (raw value, without any get_transform applied to it),
+    and a boolean indicating if the property is currently set),
+    and return the final, transformed value of the property.
+
+    The callback is responsible to ensure that value limits (min/max, length...) are respected. Otherwise a ValueError exception is raised.
     """
 
-def PointerProperty(
+def PointerProperty[_GenericType1: bpy.types.bpy_struct, _GenericType2: bpy.types.ID](
     *,
-    type: type[bpy.types.PropertyGroup | bpy.types.ID] | None = None,
+    type: type[bpy.types.PropertyGroup | bpy.types.ID] | None,
     name: str | None = "",
     description: str | None = "",
     translation_context: str | None = "*",
-    options: set[bpy._typing.rna_enums.PropertyFlagItems] = {"ANIMATABLE"},
-    override: set[bpy._typing.rna_enums.PropertyOverrideFlagItems] = set(),
-    tags=set(),
+    options: set[bpy.stub_internal.rna_enums.PropertyFlagItems] = {"ANIMATABLE"},
+    override: set[bpy.stub_internal.rna_enums.PropertyOverrideFlagItems] = set(),
+    tags: set[str] | None = set(),
     poll: collections.abc.Callable[[bpy.types.bpy_struct, bpy.types.ID], bool]
     | None = None,
-    update: collections.abc.Callable[[bpy.types.bpy_struct, bpy.types.Context], None]
+    update: collections.abc.Callable[[_GenericType1, bpy.types.Context], None]
     | None = None,
-):
+) -> None:
     """Returns a new pointer property definition.
 
-        :param type: A subclass of a property group or ID types.
-        :type type: type[bpy.types.PropertyGroup | bpy.types.ID] | None
+        :param type: A subclass of PropertyGroup or ID.
         :param name: Name used in the user interface.
-        :type name: str | None
         :param description: Text used for the tooltip and api documentation.
-        :type description: str | None
         :param translation_context: Text used as context to disambiguate translations.
-        :type translation_context: str | None
         :param options: Enumerator in `rna_enum_property_flag_items`.
-        :type options: set[bpy._typing.rna_enums.PropertyFlagItems]
         :param override: Enumerator in `rna_enum_property_override_flag_items`.
-        :type override: set[bpy._typing.rna_enums.PropertyOverrideFlagItems]
         :param tags: Enumerator of tags that are defined by parent class.
         :param poll: Function that determines whether an item is valid for this property.
     The function must take 2 values (self, object) and return a boolean.
 
     The return value will be checked only when assigning an item from the UI, but it is still possible to assign an "invalid" item to the property directly.
-        :type poll: collections.abc.Callable[[bpy.types.bpy_struct, bpy.types.ID], bool] | None
         :param update: Function to be called when this value is modified,
     This function must take 2 values (self, context) and return None.
     Warning there are no safety checks to avoid infinite recursion.
-        :type update: collections.abc.Callable[[bpy.types.bpy_struct, bpy.types.Context], None] | None
     """
 
-def RemoveProperty(*, cls: typing.Any | None, attr: str | None):
+def RemoveProperty(*, cls: typing.Any | None, attr: str | None) -> None:
     """Removes a dynamically defined property.
 
     :param cls: The class containing the property (must be a positional argument).
-    :type cls: typing.Any | None
     :param attr: Property name (must be passed as a keyword).
-    :type attr: str | None
     """
 
-def StringProperty(
+def StringProperty[_GenericType1: bpy.types.bpy_struct](
     *,
     name: str | None = "",
     description: str | None = "",
     translation_context: str | None = "*",
     default: str | None = "",
     maxlen: int | None = 0,
-    options: set[bpy._typing.rna_enums.PropertyFlagItems] = {"ANIMATABLE"},
-    override: set[bpy._typing.rna_enums.PropertyOverrideFlagItems] = set(),
-    tags=set(),
-    subtype: bpy._typing.rna_enums.PropertySubtypeStringItems = "NONE",
-    update: collections.abc.Callable[[bpy.types.bpy_struct, bpy.types.Context], None]
+    options: set[bpy.stub_internal.rna_enums.PropertyFlagItems] = {"ANIMATABLE"},
+    override: set[bpy.stub_internal.rna_enums.PropertyOverrideFlagItems] = set(),
+    tags: set[str] | None = set(),
+    subtype: bpy.stub_internal.rna_enums.PropertySubtypeStringItems = "NONE",
+    update: collections.abc.Callable[[_GenericType1, bpy.types.Context], None]
+    | None = None,
+    get: collections.abc.Callable[[_GenericType1], str] | None = None,
+    set: collections.abc.Callable[[_GenericType1, str], None] | None = None,
+    get_transform: collections.abc.Callable[[bpy.types.bpy_struct, str, bool], str]
     | None = None,
-    get: collections.abc.Callable[[bpy.types.bpy_struct], str] | None = None,
-    set: collections.abc.Callable[[bpy.types.bpy_struct, str], None] | None = None,
-    search: collections.abc.Callable[[bpy.types.bpy_struct, bpy.types.Context, str]]
+    set_transform: collections.abc.Callable[[bpy.types.bpy_struct, str, str, bool], str]
     | None = None,
-    search_options={"SUGGESTION"},
-):
+    search: collections.abc.Callable[
+        [bpy.types.bpy_struct, bpy.types.Context, str],
+        collections.abc.Iterable[str | tuple[str, str]],
+    ]
+    | None = None,
+    search_options: set[str] | None = {"SUGGESTION"},
+) -> None:
     """Returns a new string property definition.
 
         :param name: Name used in the user interface.
-        :type name: str | None
         :param description: Text used for the tooltip and api documentation.
-        :type description: str | None
         :param translation_context: Text used as context to disambiguate translations.
-        :type translation_context: str | None
         :param default: initializer string.
-        :type default: str | None
         :param maxlen: maximum length of the string.
-        :type maxlen: int | None
         :param options: Enumerator in `rna_enum_property_flag_items`.
-        :type options: set[bpy._typing.rna_enums.PropertyFlagItems]
         :param override: Enumerator in `rna_enum_property_override_flag_items`.
-        :type override: set[bpy._typing.rna_enums.PropertyOverrideFlagItems]
         :param tags: Enumerator of tags that are defined by parent class.
         :param subtype: Enumerator in `rna_enum_property_subtype_string_items`.
-        :type subtype: bpy._typing.rna_enums.PropertySubtypeStringItems
         :param update: Function to be called when this value is modified,
     This function must take 2 values (self, context) and return None.
     Warning there are no safety checks to avoid infinite recursion.
-        :type update: collections.abc.Callable[[bpy.types.bpy_struct, bpy.types.Context], None] | None
-        :param get: Function to be called when this value is 'read',
+        :param get: Function to be called when this value is read, and the default,
+    system-defined storage is not used for this property.
     This function must take 1 value (self) and return the value of the property.
-        :type get: collections.abc.Callable[[bpy.types.bpy_struct], str] | None
-        :param set: Function to be called when this value is 'written',
+
+    Defining this callback without a matching set one will make the property read-only (even if READ_ONLY option is not set).
+        :param set: Function to be called when this value is written, and the default,
+    system-defined storage is not used for this property.
     This function must take 2 values (self, value) and return None.
-        :type set: collections.abc.Callable[[bpy.types.bpy_struct, str], None] | None
+
+    Defining this callback without a matching get one is invalid.
+        :param get_transform: Function to be called when this value is read,
+    if some additional processing must be performed on the stored value.
+    This function must take three arguments (self, the stored value,
+    and a boolean indicating if the property is currently set),
+    and return the final, transformed value of the property.
+
+    The callback is responsible to ensure that value limits of the property (min/max, length...) are respected. Otherwise a ValueError exception is raised.
+        :param set_transform: Function to be called when this value is written,
+    if some additional processing must be performed on the given value before storing it.
+    This function must take four arguments (self, the given value to store,
+    the currently stored value (raw value, without any get_transform applied to it),
+    and a boolean indicating if the property is currently set),
+    and return the final, transformed value of the property.
+
+    The callback is responsible to ensure that value limits (min/max, length...) are respected. Otherwise a ValueError exception is raised.
         :param search: Function to be called to show candidates for this string (shown in the UI).
     This function must take 3 values (self, context, edit_text)
     and return a sequence, iterator or generator where each item must be:
@@ -683,12 +820,11 @@ def StringProperty(
 
     A tuple-pair of strings, where the first is a candidate and the second
     is additional information about the candidate.
-        :type search: collections.abc.Callable[[bpy.types.bpy_struct, bpy.types.Context, str]] | None
         :param search_options: Set of strings in:
 
-    'SORT' sorts the resulting items.
+    SORT sorts the resulting items.
 
-    'SUGGESTION' lets the user enter values not found in search candidates.
+    SUGGESTION lets the user enter values not found in search candidates.
     WARNING disabling this flag causes the search callback to run on redraw,
-    so only disable this flag if it's not likely to cause performance issues.
+    so only disable this flag if its not likely to cause performance issues.
     """