import typing
import collections.abc
import typing_extensions
import numpy.typing as npt
import bpy.ops
import bpy.stub_internal.rna_enums
import bpy.types

class _CLS_brush_edit(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        stroke: bpy.types.bpy_prop_collection[bpy.types.OperatorStrokeElement]
        | None = None,
        pen_flip: bool | None = False,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Apply a stroke of brush to the particles

        :param execution_context:
        :param undo:
        :param stroke: Stroke, (optional)
        :param pen_flip: Pen Flip, Whether a tablets eraser mode is being used (optional)
        :return: Result of the operator call.
        """

class _CLS_connect_hair(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        all: bool | None = False,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Connect hair to the emitter mesh

        :param execution_context:
        :param undo:
        :param all: All Hair, Connect all hair systems to the emitter mesh (optional)
        :return: Result of the operator call.
        """

class _CLS_copy_particle_systems(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        space: typing.Literal["OBJECT", "WORLD"] | None = "OBJECT",
        remove_target_particles: bool | None = True,
        use_active: bool | None = False,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Copy particle systems from the active object to selected objects

                :param execution_context:
                :param undo:
                :param space: Space, Space transform for copying from one object to another (optional)

        OBJECT
        Object -- Copy inside each objects local space.

        WORLD
        World -- Copy in world space.
                :param remove_target_particles: Remove Target Particles, Remove particle systems on the target objects (optional)
                :param use_active: Use Active, Use the active particle system from the context (optional)
                :return: Result of the operator call.
        """

class _CLS_delete(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        type: typing.Literal["PARTICLE", "KEY"] | None = "PARTICLE",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Delete selected particles or keys

        :param execution_context:
        :param undo:
        :param type: Type, Delete a full particle or only keys (optional)
        :return: Result of the operator call.
        """

class _CLS_disconnect_hair(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        all: bool | None = False,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Disconnect hair from the emitter mesh

        :param execution_context:
        :param undo:
        :param all: All Hair, Disconnect all hair systems from the emitter mesh (optional)
        :return: Result of the operator call.
        """

class _CLS_duplicate_particle_system(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        use_duplicate_settings: bool | None = False,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Duplicate particle system within the active object

        :param execution_context:
        :param undo:
        :param use_duplicate_settings: Duplicate Settings, Duplicate settings as well, so the new particle system uses its own settings (optional)
        :return: Result of the operator call.
        """

class _CLS_dupliob_copy(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Duplicate the current instance object

        :param execution_context:
        :param undo:
        :return: Result of the operator call.
        """

class _CLS_dupliob_move_down(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Move instance object down in the list

        :param execution_context:
        :param undo:
        :return: Result of the operator call.
        """

class _CLS_dupliob_move_up(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Move instance object up in the list

        :param execution_context:
        :param undo:
        :return: Result of the operator call.
        """

class _CLS_dupliob_refresh(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Refresh list of instance objects and their weights

        :param execution_context:
        :param undo:
        :return: Result of the operator call.
        """

class _CLS_dupliob_remove(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Remove the selected instance object

        :param execution_context:
        :param undo:
        :return: Result of the operator call.
        """

class _CLS_edited_clear(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Undo all edition performed on the particle system

        :param execution_context:
        :param undo:
        :return: Result of the operator call.
        """

class _CLS_hair_dynamics_preset_add(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        name: str = "",
        remove_name: bool | None = False,
        remove_active: bool | None = False,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Add or remove a Hair Dynamics Preset

        :param execution_context:
        :param undo:
        :param name: Name, Name of the preset, used to make the path name (optional, never None)
        :param remove_name: remove_name, (optional)
        :param remove_active: remove_active, (optional)
        :return: Result of the operator call.
        """

class _CLS_hide(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        unselected: bool | None = False,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Hide selected particles

        :param execution_context:
        :param undo:
        :param unselected: Unselected, Hide unselected rather than selected (optional)
        :return: Result of the operator call.
        """

class _CLS_mirror(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Duplicate and mirror the selected particles along the local X axis

        :param execution_context:
        :param undo:
        :return: Result of the operator call.
        """

class _CLS_new(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Add new particle settings

        :param execution_context:
        :param undo:
        :return: Result of the operator call.
        """

class _CLS_new_target(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Add a new particle target

        :param execution_context:
        :param undo:
        :return: Result of the operator call.
        """

class _CLS_particle_edit_toggle(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Toggle particle edit mode

        :param execution_context:
        :param undo:
        :return: Result of the operator call.
        """

class _CLS_particle_system_remove_all(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Remove all particle system within the active object

        :param execution_context:
        :param undo:
        :return: Result of the operator call.
        """

class _CLS_rekey(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        keys_number: int | None = 2,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Change the number of keys of selected particles (root and tip keys included)

        :param execution_context:
        :param undo:
        :param keys_number: Number of Keys, (in [2, inf], optional)
        :return: Result of the operator call.
        """

class _CLS_remove_doubles(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        threshold: float | None = 0.0002,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Remove selected particles close enough to others

        :param execution_context:
        :param undo:
        :param threshold: Merge Distance, Threshold distance within which particles are removed (in [0, inf], optional)
        :return: Result of the operator call.
        """

class _CLS_reveal(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        select: bool | None = True,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Show hidden particles

        :param execution_context:
        :param undo:
        :param select: Select, (optional)
        :return: Result of the operator call.
        """

class _CLS_select_all(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        action: typing.Literal["TOGGLE", "SELECT", "DESELECT", "INVERT"]
        | None = "TOGGLE",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """(De)select all particles keys

                :param execution_context:
                :param undo:
                :param action: Action, Selection action to execute (optional)

        TOGGLE
        Toggle -- Toggle selection for all elements.

        SELECT
        Select -- Select all elements.

        DESELECT
        Deselect -- Deselect all elements.

        INVERT
        Invert -- Invert selection of all elements.
                :return: Result of the operator call.
        """

class _CLS_select_less(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Deselect boundary selected keys of each particle

        :param execution_context:
        :param undo:
        :return: Result of the operator call.
        """

class _CLS_select_linked(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Select all keys linked to already selected ones

        :param execution_context:
        :param undo:
        :return: Result of the operator call.
        """

class _CLS_select_linked_pick(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        deselect: bool | None = False,
        location: collections.abc.Sequence[int] | None = (0, 0),
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Select nearest particle from mouse pointer

        :param execution_context:
        :param undo:
        :param deselect: Deselect, Deselect linked keys rather than selecting them (optional)
        :param location: Location, (array of 2 items, in [0, inf], optional)
        :return: Result of the operator call.
        """

class _CLS_select_more(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Select keys linked to boundary selected keys of each particle

        :param execution_context:
        :param undo:
        :return: Result of the operator call.
        """

class _CLS_select_random(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        ratio: float | None = 0.5,
        seed: int | None = 0,
        action: typing.Literal["SELECT", "DESELECT"] | None = "SELECT",
        type: typing.Literal["HAIR", "POINTS"] | None = "HAIR",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Select a randomly distributed set of hair or points

                :param execution_context:
                :param undo:
                :param ratio: Ratio, Portion of items to select randomly (in [0, 1], optional)
                :param seed: Random Seed, Seed for the random number generator (in [0, inf], optional)
                :param action: Action, Selection action to execute (optional)

        SELECT
        Select -- Select all elements.

        DESELECT
        Deselect -- Deselect all elements.
                :param type: Type, Select either hair or points (optional)
                :return: Result of the operator call.
        """

class _CLS_select_roots(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        action: typing.Literal["TOGGLE", "SELECT", "DESELECT", "INVERT"]
        | None = "SELECT",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Select roots of all visible particles

                :param execution_context:
                :param undo:
                :param action: Action, Selection action to execute (optional)

        TOGGLE
        Toggle -- Toggle selection for all elements.

        SELECT
        Select -- Select all elements.

        DESELECT
        Deselect -- Deselect all elements.

        INVERT
        Invert -- Invert selection of all elements.
                :return: Result of the operator call.
        """

class _CLS_select_tips(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        action: typing.Literal["TOGGLE", "SELECT", "DESELECT", "INVERT"]
        | None = "SELECT",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Select tips of all visible particles

                :param execution_context:
                :param undo:
                :param action: Action, Selection action to execute (optional)

        TOGGLE
        Toggle -- Toggle selection for all elements.

        SELECT
        Select -- Select all elements.

        DESELECT
        Deselect -- Deselect all elements.

        INVERT
        Invert -- Invert selection of all elements.
                :return: Result of the operator call.
        """

class _CLS_shape_cut(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Cut hair to conform to the set shape object

        :param execution_context:
        :param undo:
        :return: Result of the operator call.
        """

class _CLS_subdivide(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Subdivide selected particles segments (adds keys)

        :param execution_context:
        :param undo:
        :return: Result of the operator call.
        """

class _CLS_target_move_down(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Move particle target down in the list

        :param execution_context:
        :param undo:
        :return: Result of the operator call.
        """

class _CLS_target_move_up(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Move particle target up in the list

        :param execution_context:
        :param undo:
        :return: Result of the operator call.
        """

class _CLS_target_remove(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Remove the selected particle target

        :param execution_context:
        :param undo:
        :return: Result of the operator call.
        """

class _CLS_unify_length(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Make selected hair the same length

        :param execution_context:
        :param undo:
        :return: Result of the operator call.
        """

class _CLS_weight_set(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        factor: float | None = 1.0,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Set the weight of selected keys

        :param execution_context:
        :param undo:
        :param factor: Factor, Interpolation factor between current brush weight, and keys weights (in [0, 1], optional)
        :return: Result of the operator call.
        """

brush_edit: _CLS_brush_edit

connect_hair: _CLS_connect_hair

copy_particle_systems: _CLS_copy_particle_systems

delete: _CLS_delete

disconnect_hair: _CLS_disconnect_hair

duplicate_particle_system: _CLS_duplicate_particle_system

dupliob_copy: _CLS_dupliob_copy

dupliob_move_down: _CLS_dupliob_move_down

dupliob_move_up: _CLS_dupliob_move_up

dupliob_refresh: _CLS_dupliob_refresh

dupliob_remove: _CLS_dupliob_remove

edited_clear: _CLS_edited_clear

hair_dynamics_preset_add: _CLS_hair_dynamics_preset_add

hide: _CLS_hide

mirror: _CLS_mirror

new: _CLS_new

new_target: _CLS_new_target

particle_edit_toggle: _CLS_particle_edit_toggle

particle_system_remove_all: _CLS_particle_system_remove_all

rekey: _CLS_rekey

remove_doubles: _CLS_remove_doubles

reveal: _CLS_reveal

select_all: _CLS_select_all

select_less: _CLS_select_less

select_linked: _CLS_select_linked

select_linked_pick: _CLS_select_linked_pick

select_more: _CLS_select_more

select_random: _CLS_select_random

select_roots: _CLS_select_roots

select_tips: _CLS_select_tips

shape_cut: _CLS_shape_cut

subdivide: _CLS_subdivide

target_move_down: _CLS_target_move_down

target_move_up: _CLS_target_move_up

target_remove: _CLS_target_remove

unify_length: _CLS_unify_length

weight_set: _CLS_weight_set
