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_active_frame_delete(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]]:
        """Delete the active Grease Pencil frame(s)

        :param execution_context:
        :param undo:
        :param all: Delete all, Delete active keyframes of all layers (optional)
        :return: Result of the operator call.
        """

class _CLS_bake_grease_pencil_animation(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        frame_start: int | None = 1,
        frame_end: int | None = 250,
        step: int | None = 1,
        only_selected: bool | None = False,
        frame_target: int | None = 1,
        project_type: typing.Literal["KEEP", "FRONT", "SIDE", "TOP", "VIEW", "CURSOR"]
        | None = "KEEP",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Bake Grease Pencil object transform to Grease Pencil keyframes

                :param execution_context:
                :param undo:
                :param frame_start: Start Frame, The start frame (in [1, 100000], optional)
                :param frame_end: End Frame, The end frame of animation (in [1, 100000], optional)
                :param step: Step, Step between generated frames (in [1, 100], optional)
                :param only_selected: Only Selected Keyframes, Convert only selected keyframes (optional)
                :param frame_target: Target Frame, Destination frame (in [1, 100000], optional)
                :param project_type: Projection Type, (optional)

        KEEP
        No Reproject.

        FRONT
        Front -- Reproject the strokes using the X-Z plane.

        SIDE
        Side -- Reproject the strokes using the Y-Z plane.

        TOP
        Top -- Reproject the strokes using the X-Y plane.

        VIEW
        View -- Reproject the strokes to end up on the same plane, as if drawn from the current viewpoint using Cursor Stroke Placement.

        CURSOR
        Cursor -- Reproject the strokes using the orientation of 3D cursor.
                :return: Result of the operator call.
        """

class _CLS_brush_stroke(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,
        mode: typing.Literal["NORMAL", "INVERT"] | None = "NORMAL",
        brush_toggle: typing.Literal["None", "SMOOTH", "ERASE", "MASK"] | None = "None",
        pen_flip: bool | None = False,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Draw a new stroke in the active Grease Pencil object

                :param execution_context:
                :param undo:
                :param stroke: Stroke, (optional)
                :param mode: Stroke Mode, Action taken when a paint stroke is made (optional)

        NORMAL
        Regular -- Apply brush normally.

        INVERT
        Invert -- Invert action of brush for duration of stroke.
                :param brush_toggle: Temporary Brush Toggle Type, Brush to use for duration of stroke (optional)

        None
        None -- Apply brush normally.

        SMOOTH
        Smooth -- Switch to smooth brush for duration of stroke.

        ERASE
        Erase -- Switch to erase brush for duration of stroke.

        MASK
        Mask -- Switch to mask brush for duration of stroke.
                :param pen_flip: Pen Flip, Whether a tablets eraser mode is being used (optional)
                :return: Result of the operator call.
        """

class _CLS_caps_set(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        type: typing.Literal["ROUND", "FLAT", "START", "END"] | None = "ROUND",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Change curve caps mode (rounded or flat)

                :param execution_context:
                :param undo:
                :param type: Type, (optional)

        ROUND
        Rounded -- Set as default rounded.

        FLAT
        Flat.

        START
        Toggle Start.

        END
        Toggle End.
                :return: Result of the operator call.
        """

class _CLS_clean_loose(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        limit: int | None = 1,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Remove loose points

        :param execution_context:
        :param undo:
        :param limit: Limit, Number of points to consider stroke as loose (in [1, inf], optional)
        :return: Result of the operator call.
        """

class _CLS_convert_curve_type(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        type: typing.Literal[bpy.stub_internal.rna_enums.CurvesTypeItems]
        | None = "POLY",
        threshold: float | None = 0.01,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Convert type of selected curves

        :param execution_context:
        :param undo:
        :param type: Type, (optional)
        :param threshold: Threshold, The distance that the resulting points are allowed to be within (in [0, 100], optional)
        :return: Result of the operator call.
        """

class _CLS_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]]:
        """Copy the selected Grease Pencil points or strokes to the internal clipboard

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

class _CLS_cyclical_set(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        type: typing.Literal["CLOSE", "OPEN", "TOGGLE"] | None = "TOGGLE",
        subdivide_cyclic_segment: bool | None = True,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Close or open the selected stroke adding a segment from last to first point

        :param execution_context:
        :param undo:
        :param type: Type, (optional)
        :param subdivide_cyclic_segment: Match Point Density, Add point in the new segment to keep the same density (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,
        /,
        *,
        mode: typing.Literal["ALL", "STROKES", "FILLS"] | None = "ALL",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Delete selected strokes or points

                :param execution_context:
                :param undo:
                :param mode: Mode, The kind of strokes or fills to delete (optional)

        ALL
        All -- Delete all selected strokes or points.

        STROKES
        Only Strokes -- Delete only strokes and not fills.

        FILLS
        Only Fills -- Delete only fills and not strokes.
                :return: Result of the operator call.
        """

class _CLS_delete_breakdown(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 breakdown frames generated by interpolating between two Grease Pencil frames

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

class _CLS_delete_frame(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        type: typing.Literal["ACTIVE_FRAME", "ALL_FRAMES"] | None = "ACTIVE_FRAME",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Delete Grease Pencil Frame(s)

                :param execution_context:
                :param undo:
                :param type: Type, Method used for deleting Grease Pencil frames (optional)

        ACTIVE_FRAME
        Active Frame -- Deletes current frame in the active layer.

        ALL_FRAMES
        All Active Frames -- Delete active frames for all layers.
                :return: Result of the operator call.
        """

class _CLS_dissolve(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        type: typing.Literal["POINTS", "BETWEEN", "UNSELECT"] | None = "POINTS",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Delete selected points without splitting strokes

                :param execution_context:
                :param undo:
                :param type: Type, Method used for dissolving stroke points (optional)

        POINTS
        Dissolve -- Dissolve selected points.

        BETWEEN
        Dissolve Between -- Dissolve points between selected points.

        UNSELECT
        Dissolve Unselect -- Dissolve all unselected points.
                :return: Result of the operator call.
        """

class _CLS_duplicate(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 selected points

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

class _CLS_duplicate_move(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        GREASE_PENCIL_OT_duplicate: dict[str, typing.Any] | None = {},
        TRANSFORM_OT_translate: dict[str, typing.Any] | None = {},
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Make copies of the selected Grease Pencil strokes and move them

        :param execution_context:
        :param undo:
        :param GREASE_PENCIL_OT_duplicate: Duplicate, Duplicate the selected points (optional, `bpy.ops.grease_pencil.duplicate` keyword arguments)
        :param TRANSFORM_OT_translate: Move, Move selected items (optional, `bpy.ops.transform.translate` keyword arguments)
        :return: Result of the operator call.
        """

class _CLS_erase_box(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        xmin: int | None = 0,
        xmax: int | None = 0,
        ymin: int | None = 0,
        ymax: int | None = 0,
        wait_for_input: bool | None = True,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Erase points in the box region

        :param execution_context:
        :param undo:
        :param xmin: X Min, (in [-inf, inf], optional)
        :param xmax: X Max, (in [-inf, inf], optional)
        :param ymin: Y Min, (in [-inf, inf], optional)
        :param ymax: Y Max, (in [-inf, inf], optional)
        :param wait_for_input: Wait for Input, (optional)
        :return: Result of the operator call.
        """

class _CLS_erase_lasso(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        path: bpy.types.bpy_prop_collection[bpy.types.OperatorMousePath] | None = None,
        use_smooth_stroke: bool | None = False,
        smooth_stroke_factor: float | None = 0.75,
        smooth_stroke_radius: int | None = 35,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Erase points in the lasso region

        :param execution_context:
        :param undo:
        :param path: Path, (optional)
        :param use_smooth_stroke: Stabilize Stroke, Selection lags behind mouse and follows a smoother path (optional)
        :param smooth_stroke_factor: Smooth Stroke Factor, Higher values give a smoother stroke (in [0.5, 0.99], optional)
        :param smooth_stroke_radius: Smooth Stroke Radius, Minimum distance from last point before selection continues (in [10, 200], optional)
        :return: Result of the operator call.
        """

class _CLS_extrude(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]]:
        """Extrude the selected points

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

class _CLS_extrude_move(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        GREASE_PENCIL_OT_extrude: dict[str, typing.Any] | None = {},
        TRANSFORM_OT_translate: dict[str, typing.Any] | None = {},
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Extrude selected points and move them

        :param execution_context:
        :param undo:
        :param GREASE_PENCIL_OT_extrude: Extrude Stroke Points, Extrude the selected points (optional, `bpy.ops.grease_pencil.extrude` keyword arguments)
        :param TRANSFORM_OT_translate: Move, Move selected items (optional, `bpy.ops.transform.translate` keyword arguments)
        :return: Result of the operator call.
        """

class _CLS_fill(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        invert: bool | None = False,
        precision: bool | None = False,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Fill with color the shape formed by strokes

        :param execution_context:
        :param undo:
        :param invert: Invert, Find boundary of unfilled instead of filled regions (optional)
        :param precision: Precision, Use precision movement for extension lines (optional)
        :return: Result of the operator call.
        """

class _CLS_frame_clean_duplicate(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        selected: bool | None = False,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Remove any keyframe that is a duplicate of the previous one

        :param execution_context:
        :param undo:
        :param selected: Selected, Only delete selected keyframes (optional)
        :return: Result of the operator call.
        """

class _CLS_frame_duplicate(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]]:
        """Make a copy of the active Grease Pencil frame(s)

        :param execution_context:
        :param undo:
        :param all: Duplicate all, Duplicate active keyframes of all layer (optional)
        :return: Result of the operator call.
        """

class _CLS_insert_blank_frame(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        all_layers: bool | None = False,
        duration: int | None = 0,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Insert a blank frame on the current scene frame

        :param execution_context:
        :param undo:
        :param all_layers: All Layers, Insert a blank frame in all editable layers (optional)
        :param duration: Duration, (in [0, 1048574], optional)
        :return: Result of the operator call.
        """

class _CLS_interpolate(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        shift: float | None = 0.0,
        layers: typing.Literal["ACTIVE", "ALL"] | None = "ACTIVE",
        exclude_breakdowns: bool | None = False,
        use_selection: bool | None = False,
        flip: typing.Literal["NONE", "FLIP", "AUTO"] | None = "AUTO",
        smooth_steps: int | None = 1,
        smooth_factor: float | None = 0.0,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Interpolate Grease Pencil strokes between frames

        :param execution_context:
        :param undo:
        :param shift: Shift, Bias factor for which frame has more influence on the interpolated strokes (in [-1, 1], optional)
        :param layers: Layer, Layers included in the interpolation (optional)
        :param exclude_breakdowns: Exclude Breakdowns, Exclude existing Breakdowns keyframes as interpolation extremes (optional)
        :param use_selection: Use Selection, Use only selected strokes for interpolating (optional)
        :param flip: Flip Mode, Invert destination stroke to match start and end with source stroke (optional)
        :param smooth_steps: Iterations, Number of times to smooth newly created strokes (in [1, 3], optional)
        :param smooth_factor: Smooth, Amount of smoothing to apply to interpolated strokes, to reduce jitter/noise (in [0, 2], optional)
        :return: Result of the operator call.
        """

class _CLS_interpolate_sequence(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        step: int | None = 1,
        layers: typing.Literal["ACTIVE", "ALL"] | None = "ACTIVE",
        exclude_breakdowns: bool | None = False,
        use_selection: bool | None = False,
        flip: typing.Literal["NONE", "FLIP", "AUTO"] | None = "AUTO",
        smooth_steps: int | None = 1,
        smooth_factor: float | None = 0.0,
        type: typing.Literal[
            "LINEAR",
            "CUSTOM",
            "SINE",
            "QUAD",
            "CUBIC",
            "QUART",
            "QUINT",
            "EXPO",
            "CIRC",
            "BACK",
            "BOUNCE",
            "ELASTIC",
        ]
        | None = "LINEAR",
        easing: typing.Literal[
            bpy.stub_internal.rna_enums.BeztripleInterpolationEasingItems
        ]
        | None = "EASE_IN",
        back: float | None = 1.702,
        amplitude: float | None = 0.15,
        period: float | None = 0.15,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Generate in-betweens to smoothly interpolate between Grease Pencil frames

                :param execution_context:
                :param undo:
                :param step: Step, Number of frames between generated interpolated frames (in [1, 1048574], optional)
                :param layers: Layer, Layers included in the interpolation (optional)
                :param exclude_breakdowns: Exclude Breakdowns, Exclude existing Breakdowns keyframes as interpolation extremes (optional)
                :param use_selection: Use Selection, Use only selected strokes for interpolating (optional)
                :param flip: Flip Mode, Invert destination stroke to match start and end with source stroke (optional)
                :param smooth_steps: Iterations, Number of times to smooth newly created strokes (in [1, 3], optional)
                :param smooth_factor: Smooth, Amount of smoothing to apply to interpolated strokes, to reduce jitter/noise (in [0, 2], optional)
                :param type: Type, Interpolation method to use the next time Interpolate Sequence is run (optional)

        LINEAR
        Linear -- Straight-line interpolation between A and B (i.e. no ease in/out).

        CUSTOM
        Custom -- Custom interpolation defined using a curve map.

        SINE
        Sinusoidal -- Sinusoidal easing (weakest, almost linear but with a slight curvature).

        QUAD
        Quadratic -- Quadratic easing.

        CUBIC
        Cubic -- Cubic easing.

        QUART
        Quartic -- Quartic easing.

        QUINT
        Quintic -- Quintic easing.

        EXPO
        Exponential -- Exponential easing (dramatic).

        CIRC
        Circular -- Circular easing (strongest and most dynamic).

        BACK
        Back -- Cubic easing with overshoot and settle.

        BOUNCE
        Bounce -- Exponentially decaying parabolic bounce, like when objects collide.

        ELASTIC
        Elastic -- Exponentially decaying sine wave, like an elastic band.
                :param easing: Easing, Which ends of the segment between the preceding and following Grease Pencil frames easing interpolation is applied to (optional)
                :param back: Back, Amount of overshoot for back easing (in [0, inf], optional)
                :param amplitude: Amplitude, Amount to boost elastic bounces for elastic easing (in [0, inf], optional)
                :param period: Period, Time between bounces for elastic easing (in [-inf, inf], optional)
                :return: Result of the operator call.
        """

class _CLS_join_fills(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]]:
        """Join selected strokes into one fill to create holes

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

class _CLS_join_selection(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        type: typing.Literal["JOINSTROKES", "SPLITCOPY", "SPLIT"]
        | None = "JOINSTROKES",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """New stroke from selected points/strokes

                :param execution_context:
                :param undo:
                :param type: Type, Defines how the operator will behave on the selection in the active layer (optional)

        JOINSTROKES
        Join Strokes -- Join the selected strokes into one stroke.

        SPLITCOPY
        Split and Copy -- Copy the selected points to a new stroke.

        SPLIT
        Split -- Split the selected point to a new stroke.
                :return: Result of the operator call.
        """

class _CLS_layer_active(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        layer: int | None = 0,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Set the active Grease Pencil layer

        :param execution_context:
        :param undo:
        :param layer: Grease Pencil Layer, (in [0, inf], optional)
        :return: Result of the operator call.
        """

class _CLS_layer_add(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        new_layer_name: str = "Layer",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Add a new Grease Pencil layer in the active object

        :param execution_context:
        :param undo:
        :param new_layer_name: Name, Name of the new layer (optional, never None)
        :return: Result of the operator call.
        """

class _CLS_layer_duplicate(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        empty_keyframes: bool | None = False,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Make a copy of the active Grease Pencil layer

        :param execution_context:
        :param undo:
        :param empty_keyframes: Empty Keyframes, Add Empty Keyframes (optional)
        :return: Result of the operator call.
        """

class _CLS_layer_duplicate_object(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        only_active: bool | None = True,
        mode: typing.Literal["ALL", "ACTIVE"] | None = "ALL",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Make a copy of the active Grease Pencil layer to selected object

        :param execution_context:
        :param undo:
        :param only_active: Only Active, Copy only active Layer, uncheck to append all layers (optional)
        :param mode: Mode, (optional)
        :return: Result of the operator call.
        """

class _CLS_layer_group_add(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        new_layer_group_name: str = "",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Add a new Grease Pencil layer group in the active object

        :param execution_context:
        :param undo:
        :param new_layer_group_name: Name, Name of the new layer group (optional, never None)
        :return: Result of the operator call.
        """

class _CLS_layer_group_color_tag(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        color_tag: typing.Literal[
            "NONE",
            "COLOR1",
            "COLOR2",
            "COLOR3",
            "COLOR4",
            "COLOR5",
            "COLOR6",
            "COLOR7",
            "COLOR8",
        ]
        | None = "COLOR1",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Change layer group icon

        :param execution_context:
        :param undo:
        :param color_tag: Color Tag, (optional)
        :return: Result of the operator call.
        """

class _CLS_layer_group_remove(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        keep_children: bool | None = False,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Remove Grease Pencil layer group in the active object

        :param execution_context:
        :param undo:
        :param keep_children: Keep children nodes, Keep the children nodes of the group and only delete the group itself (optional)
        :return: Result of the operator call.
        """

class _CLS_layer_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/unselected Grease Pencil layers

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

class _CLS_layer_isolate(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        affect_visibility: bool | None = False,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Make only active layer visible/editable

        :param execution_context:
        :param undo:
        :param affect_visibility: Affect Visibility, Also affect the visibility (optional)
        :return: Result of the operator call.
        """

class _CLS_layer_lock_all(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        lock: bool | None = True,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Lock all Grease Pencil layers to prevent them from being accidentally modified

        :param execution_context:
        :param undo:
        :param lock: Lock Value, Lock/Unlock all layers (optional)
        :return: Result of the operator call.
        """

class _CLS_layer_mask_add(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        name: str = "",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Add new layer as masking

        :param execution_context:
        :param undo:
        :param name: Layer, Name of the layer (optional, never None)
        :return: Result of the operator call.
        """

class _CLS_layer_mask_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 Layer Mask

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

class _CLS_layer_mask_reorder(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        direction: typing.Literal["UP", "DOWN"] | None = "UP",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Reorder the active Grease Pencil mask layer up/down in the list

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

class _CLS_layer_merge(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        mode: typing.Literal["ACTIVE", "GROUP", "ALL"] | None = "ACTIVE",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Combine layers based on the mode into one layer

                :param execution_context:
                :param undo:
                :param mode: Mode, (optional)

        ACTIVE
        Active -- Combine the active layer with the layer just below (if it exists).

        GROUP
        Group -- Combine layers in the active group into a single layer.

        ALL
        All -- Combine all layers into a single layer.
                :return: Result of the operator call.
        """

class _CLS_layer_move(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        direction: typing.Literal["UP", "DOWN"] | None = "UP",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Move the active Grease Pencil layer or Group

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

class _CLS_layer_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 active Grease Pencil layer

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

class _CLS_layer_reveal(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]]:
        """Show all Grease Pencil layers

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

class _CLS_material_copy_to_object(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        only_active: bool | None = True,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Append Materials of the active Grease Pencil to other object

        :param execution_context:
        :param undo:
        :param only_active: Only Active, Append only active material, uncheck to append all materials (optional)
        :return: Result of the operator call.
        """

class _CLS_material_hide(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        invert: bool | None = False,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Hide active/inactive Grease Pencil material(s)

        :param execution_context:
        :param undo:
        :param invert: Invert, Hide inactive materials instead of the active one (optional)
        :return: Result of the operator call.
        """

class _CLS_material_isolate(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        affect_visibility: bool | None = False,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Toggle whether the active material is the only one that is editable and/or visible

        :param execution_context:
        :param undo:
        :param affect_visibility: Affect Visibility, In addition to toggling the editability, also affect the visibility (optional)
        :return: Result of the operator call.
        """

class _CLS_material_lock_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]]:
        """Lock all Grease Pencil materials to prevent them from being accidentally modified

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

class _CLS_material_lock_unselected(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]]:
        """Lock any material not used in any selected stroke

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

class _CLS_material_lock_unused(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]]:
        """Lock and hide any material not used

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

class _CLS_material_reveal(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]]:
        """Unhide all hidden Grease Pencil materials

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

class _CLS_material_select(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        deselect: bool | None = False,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Select/Deselect all Grease Pencil strokes using current material

        :param execution_context:
        :param undo:
        :param deselect: Deselect, Unselect strokes (optional)
        :return: Result of the operator call.
        """

class _CLS_material_unlock_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]]:
        """Unlock all Grease Pencil materials so that they can be edited

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

class _CLS_move_to_layer(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        target_layer_name: str = "",
        target_group_name: str = "",
        add_new_layer: bool | None = False,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Move selected strokes to another layer

        :param execution_context:
        :param undo:
        :param target_layer_name: Name, Target Grease Pencil Layer (optional, never None)
        :param target_group_name: Target Group, Group to add the new layer to (optional, never None)
        :param add_new_layer: New Layer, Move selection to a new layer (optional)
        :return: Result of the operator call.
        """

class _CLS_outline(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        type: typing.Literal["VIEW", "FRONT", "SIDE", "TOP", "CURSOR", "CAMERA"]
        | None = "VIEW",
        radius: float | None = 0.01,
        offset_factor: float | None = -1.0,
        corner_subdivisions: int | None = 2,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Convert selected strokes to perimeter

        :param execution_context:
        :param undo:
        :param type: Projection Mode, (optional)
        :param radius: Radius, (in [0, 10], optional)
        :param offset_factor: Offset Factor, (in [-1, 1], optional)
        :param corner_subdivisions: Corner Subdivisions, (in [0, 10], optional)
        :return: Result of the operator call.
        """

class _CLS_paintmode_toggle(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        back: bool | None = False,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Enter/Exit paint mode for Grease Pencil strokes

        :param execution_context:
        :param undo:
        :param back: Return to Previous Mode, Return to previous mode (optional)
        :return: Result of the operator call.
        """

class _CLS_paste(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        type: typing.Literal["ACTIVE", "LAYER"] | None = "ACTIVE",
        paste_back: bool | None = False,
        keep_world_transform: bool | None = False,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Paste Grease Pencil points or strokes from the internal clipboard to the active layer

        :param execution_context:
        :param undo:
        :param type: Type, (optional)
        :param paste_back: Paste on Back, Add pasted strokes behind all strokes (optional)
        :param keep_world_transform: Keep World Transform, Keep the world transform of strokes from the clipboard unchanged (optional)
        :return: Result of the operator call.
        """

class _CLS_pen(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        extend: bool | None = False,
        deselect: bool | None = False,
        toggle: bool | None = False,
        deselect_all: bool | None = False,
        select_passthrough: bool | None = False,
        extrude_point: bool | None = False,
        extrude_handle: typing.Literal["AUTO", "VECTOR"] | None = "VECTOR",
        delete_point: bool | None = False,
        insert_point: bool | None = False,
        move_segment: bool | None = False,
        select_point: bool | None = False,
        move_point: bool | None = False,
        cycle_handle_type: bool | None = False,
        size: float | None = 0.01,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Construct and edit splines

        :param execution_context:
        :param undo:
        :param extend: Extend, Extend selection instead of deselecting everything first (optional)
        :param deselect: Deselect, Remove from selection (optional)
        :param toggle: Toggle Selection, Toggle the selection (optional)
        :param deselect_all: Deselect On Nothing, Deselect all when nothing under the cursor (optional)
        :param select_passthrough: Only Select Unselected, Ignore the select action when the element is already selected (optional)
        :param extrude_point: Extrude Point, Add a point connected to the last selected point (optional)
        :param extrude_handle: Extrude Handle Type, Type of the extruded handle (optional)
        :param delete_point: Delete Point, Delete an existing point (optional)
        :param insert_point: Insert Point, Insert Point into a curve segment (optional)
        :param move_segment: Move Segment, Move an existing curve segment (optional)
        :param select_point: Select Point, Select a point or its handles (optional)
        :param move_point: Move Point, Move a point or its handles (optional)
        :param cycle_handle_type: Cycle Handle Type, Cycle between all four handle types (optional)
        :param size: Size, Diameter of new points (in [0, inf], optional)
        :return: Result of the operator call.
        """

class _CLS_primitive_arc(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        subdivision: int | None = 62,
        type: typing.Literal["BOX", "LINE", "POLYLINE", "CIRCLE", "ARC", "CURVE"]
        | None = "ARC",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Create predefined Grease Pencil stroke arcs

        :param execution_context:
        :param undo:
        :param subdivision: Subdivisions, Number of subdivisions per segment (in [0, inf], optional)
        :param type: Type, Type of shape (optional)
        :return: Result of the operator call.
        """

class _CLS_primitive_box(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        subdivision: int | None = 3,
        type: typing.Literal["BOX", "LINE", "POLYLINE", "CIRCLE", "ARC", "CURVE"]
        | None = "BOX",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Create predefined Grease Pencil stroke boxes

        :param execution_context:
        :param undo:
        :param subdivision: Subdivisions, Number of subdivisions per segment (in [0, inf], optional)
        :param type: Type, Type of shape (optional)
        :return: Result of the operator call.
        """

class _CLS_primitive_circle(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        subdivision: int | None = 94,
        type: typing.Literal["BOX", "LINE", "POLYLINE", "CIRCLE", "ARC", "CURVE"]
        | None = "CIRCLE",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Create predefined Grease Pencil stroke circles

        :param execution_context:
        :param undo:
        :param subdivision: Subdivisions, Number of subdivisions per segment (in [0, inf], optional)
        :param type: Type, Type of shape (optional)
        :return: Result of the operator call.
        """

class _CLS_primitive_curve(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        subdivision: int | None = 62,
        type: typing.Literal["BOX", "LINE", "POLYLINE", "CIRCLE", "ARC", "CURVE"]
        | None = "CURVE",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Create predefined Grease Pencil stroke curve shapes

        :param execution_context:
        :param undo:
        :param subdivision: Subdivisions, Number of subdivisions per segment (in [0, inf], optional)
        :param type: Type, Type of shape (optional)
        :return: Result of the operator call.
        """

class _CLS_primitive_line(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        subdivision: int | None = 6,
        type: typing.Literal["BOX", "LINE", "POLYLINE", "CIRCLE", "ARC", "CURVE"]
        | None = "LINE",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Create predefined Grease Pencil stroke lines

        :param execution_context:
        :param undo:
        :param subdivision: Subdivisions, Number of subdivisions per segment (in [0, inf], optional)
        :param type: Type, Type of shape (optional)
        :return: Result of the operator call.
        """

class _CLS_primitive_polyline(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        subdivision: int | None = 6,
        type: typing.Literal["BOX", "LINE", "POLYLINE", "CIRCLE", "ARC", "CURVE"]
        | None = "POLYLINE",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Create predefined Grease Pencil stroke polylines

        :param execution_context:
        :param undo:
        :param subdivision: Subdivisions, Number of subdivisions per segment (in [0, inf], optional)
        :param type: Type, Type of shape (optional)
        :return: Result of the operator call.
        """

class _CLS_relative_layer_mask_add(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        mode: typing.Literal["ABOVE", "BELOW"] | None = "ABOVE",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Mask active layer with layer above or below

        :param execution_context:
        :param undo:
        :param mode: Mode, Which relative layer (above or below) to use as a mask (optional)
        :return: Result of the operator call.
        """

class _CLS_remove_fill_guides(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        mode: typing.Literal["ACTIVE_FRAME", "ALL_FRAMES"] | None = "ALL_FRAMES",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Remove all the strokes that were created from the fill tool as guides

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

class _CLS_reorder(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        direction: typing.Literal["TOP", "UP", "DOWN", "BOTTOM"] | None = "TOP",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Change the display order of the selected strokes

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

class _CLS_reproject(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        type: typing.Literal["FRONT", "SIDE", "TOP", "VIEW", "SURFACE", "CURSOR"]
        | None = "VIEW",
        keep_original: bool | None = False,
        offset: float | None = 0.0,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Reproject the selected strokes from the current viewpoint as if they had been newly drawn (e.g. to fix problems from accidental 3D cursor movement or accidental viewport changes, or for matching deforming geometry)

                :param execution_context:
                :param undo:
                :param type: Projection Type, (optional)

        FRONT
        Front -- Reproject the strokes using the X-Z plane.

        SIDE
        Side -- Reproject the strokes using the Y-Z plane.

        TOP
        Top -- Reproject the strokes using the X-Y plane.

        VIEW
        View -- Reproject the strokes to end up on the same plane, as if drawn from the current viewpoint using Cursor Stroke Placement.

        SURFACE
        Surface -- Reproject the strokes on to the scene geometry, as if drawn using Surface placement.

        CURSOR
        Cursor -- Reproject the strokes using the orientation of 3D cursor.
                :param keep_original: Keep Original, Keep original strokes and create a copy before reprojecting (optional)
                :param offset: Surface Offset, (in [0, 10], optional)
                :return: Result of the operator call.
        """

class _CLS_reset_uvs(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]]:
        """Reset UV transformation to default values

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

class _CLS_sculpt_paint(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,
        mode: typing.Literal["NORMAL", "INVERT"] | None = "NORMAL",
        brush_toggle: typing.Literal["None", "SMOOTH", "ERASE", "MASK"] | None = "None",
        pen_flip: bool | None = False,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Sculpt strokes in the active Grease Pencil object

                :param execution_context:
                :param undo:
                :param stroke: Stroke, (optional)
                :param mode: Stroke Mode, Action taken when a paint stroke is made (optional)

        NORMAL
        Regular -- Apply brush normally.

        INVERT
        Invert -- Invert action of brush for duration of stroke.
                :param brush_toggle: Temporary Brush Toggle Type, Brush to use for duration of stroke (optional)

        None
        None -- Apply brush normally.

        SMOOTH
        Smooth -- Switch to smooth brush for duration of stroke.

        ERASE
        Erase -- Switch to erase brush for duration of stroke.

        MASK
        Mask -- Switch to mask brush for duration of stroke.
                :param pen_flip: Pen Flip, Whether a tablets eraser mode is being used (optional)
                :return: Result of the operator call.
        """

class _CLS_sculptmode_toggle(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        back: bool | None = False,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Enter/Exit sculpt mode for Grease Pencil strokes

        :param execution_context:
        :param undo:
        :param back: Return to Previous Mode, Return to previous mode (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 visible strokes

                :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_alternate(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        deselect_ends: bool | None = False,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Select alternated points in strokes with already selected points

        :param execution_context:
        :param undo:
        :param deselect_ends: Deselect Ends, (De)select the first and last point of each stroke (optional)
        :return: Result of the operator call.
        """

class _CLS_select_by_stroke_type(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        type: typing.Literal["STROKE", "FILL"] | None = "STROKE",
        deselect: bool | None = False,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Select/Deselect all strokes or fills

        :param execution_context:
        :param undo:
        :param type: Type, (optional)
        :param deselect: Deselect, Unselect strokes (optional)
        :return: Result of the operator call.
        """

class _CLS_select_ends(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        amount_start: int | None = 0,
        amount_end: int | None = 1,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Select end points of strokes

        :param execution_context:
        :param undo:
        :param amount_start: Amount Start, Number of points to select from the start (in [0, inf], optional)
        :param amount_end: Amount End, Number of points to select from the end (in [0, inf], optional)
        :return: Result of the operator call.
        """

class _CLS_select_fill(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 curves in a fill

        :param execution_context:
        :param undo:
        :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]]:
        """Shrink the selection by one point

        :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 points in curves with any point selection

        :param execution_context:
        :param undo:
        :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]]:
        """Grow the selection by one point

        :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",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Selects random points from the current strokes selection

                :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.
                :return: Result of the operator call.
        """

class _CLS_select_similar(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        mode: typing.Literal["LAYER", "MATERIAL", "VERTEX_COLOR", "RADIUS", "OPACITY"]
        | None = "LAYER",
        threshold: float | None = 0.1,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Select all strokes with similar characteristics

        :param execution_context:
        :param undo:
        :param mode: Mode, (optional)
        :param threshold: Threshold, (in [0, inf], optional)
        :return: Result of the operator call.
        """

class _CLS_separate(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        mode: typing.Literal["SELECTED", "MATERIAL", "LAYER"] | None = "SELECTED",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Separate the selected geometry into a new Grease Pencil object

                :param execution_context:
                :param undo:
                :param mode: Mode, (optional)

        SELECTED
        Selection -- Separate selected geometry.

        MATERIAL
        By Material -- Separate by material.

        LAYER
        By Layer -- Separate by layer.
                :return: Result of the operator call.
        """

class _CLS_separate_fills(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        individual: bool | None = True,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Separate the selected strokes from current fill

        :param execution_context:
        :param undo:
        :param individual: Individual, Create a separate fill for each individual stroke (optional)
        :return: Result of the operator call.
        """

class _CLS_set_active_material(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]]:
        """Set the selected stroke material as the active material

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

class _CLS_set_corner_type(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        corner_type: typing.Literal["ROUND", "FLAT", "SHARP"] | None = "SHARP",
        miter_angle: float | None = 0.785398,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Set the corner type of the selected points

        :param execution_context:
        :param undo:
        :param corner_type: Corner Type, (optional)
        :param miter_angle: Miter Cut Angle, All corners sharper than the Miter angle will be cut flat (in [0, 3.14159], optional)
        :return: Result of the operator call.
        """

class _CLS_set_curve_resolution(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        resolution: int | None = 12,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Set resolution of selected curves

        :param execution_context:
        :param undo:
        :param resolution: Resolution, The resolution to use for each curve segment (in [0, 10000], optional)
        :return: Result of the operator call.
        """

class _CLS_set_curve_type(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        type: typing.Literal[bpy.stub_internal.rna_enums.CurvesTypeItems]
        | None = "POLY",
        use_handles: bool | None = False,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Set type of selected curves

        :param execution_context:
        :param undo:
        :param type: Type, Curve type (optional)
        :param use_handles: Handles, Take handle information into account in the conversion (optional)
        :return: Result of the operator call.
        """

class _CLS_set_handle_type(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        type: typing.Literal[
            "AUTO", "VECTOR", "ALIGN", "FREE_ALIGN", "TOGGLE_FREE_ALIGN"
        ]
        | None = "AUTO",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Set the handle type for Bézier curves

                :param execution_context:
                :param undo:
                :param type: Type, (optional)

        AUTO
        Auto -- The location is automatically calculated to be smooth.

        VECTOR
        Vector -- The location is calculated to point to the next/previous control point.

        ALIGN
        Align -- The location is constrained to point in the opposite direction as the other handle.

        FREE_ALIGN
        Free -- The handle can be moved anywhere, and does not influence the points other handle.

        TOGGLE_FREE_ALIGN
        Toggle Free/Align -- Replace Free handles with Align, and all Align with Free handles.
                :return: Result of the operator call.
        """

class _CLS_set_material(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        slot: typing.Literal["DEFAULT"] | None = "DEFAULT",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Set active material

        :param execution_context:
        :param undo:
        :param slot: Material Slot, (optional)
        :return: Result of the operator call.
        """

class _CLS_set_selection_mode(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        mode: typing.Literal[bpy.stub_internal.rna_enums.GreasePencilSelectmodeItems]
        | None = "POINT",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Change the selection mode for Grease Pencil strokes

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

class _CLS_set_start_point(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 which point is the beginning of the curve

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

class _CLS_set_stroke_type(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        type: typing.Literal["STROKE", "FILL", "BOTH"] | None = "STROKE",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Set the stroke type (stroke, fill, or both) of the selected strokes

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

class _CLS_set_uniform_opacity(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        opacity_stroke: float | None = 1.0,
        opacity_fill: float | None = 0.5,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Set all stroke points to same opacity

        :param execution_context:
        :param undo:
        :param opacity_stroke: Stroke Opacity, (in [0, 1], optional)
        :param opacity_fill: Fill Opacity, (in [0, 1], optional)
        :return: Result of the operator call.
        """

class _CLS_set_uniform_thickness(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        thickness: float | None = 0.1,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Set all stroke points to same thickness

        :param execution_context:
        :param undo:
        :param thickness: Thickness, Thickness (in [0, 1000], optional)
        :return: Result of the operator call.
        """

class _CLS_snap_cursor_to_selected(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]]:
        """Snap cursor to center of selected points

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

class _CLS_snap_to_cursor(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        use_offset: bool | None = True,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Snap selected points/strokes to the cursor

        :param execution_context:
        :param undo:
        :param use_offset: With Offset, Offset the entire stroke instead of selected points only (optional)
        :return: Result of the operator call.
        """

class _CLS_snap_to_grid(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]]:
        """Snap selected points to the nearest grid points

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

class _CLS_stroke_material_set(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        material: str = "",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Assign the active material slot to the selected strokes

        :param execution_context:
        :param undo:
        :param material: Material, Name of the material (optional, never None)
        :return: Result of the operator call.
        """

class _CLS_stroke_merge_by_distance(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        threshold: float | None = 0.001,
        use_unselected: bool | None = False,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Merge points by distance

        :param execution_context:
        :param undo:
        :param threshold: Threshold, (in [0, 100], optional)
        :param use_unselected: Unselected, Use whole stroke, not only selected points (optional)
        :return: Result of the operator call.
        """

class _CLS_stroke_reset_vertex_color(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        mode: typing.Literal["STROKE", "FILL", "BOTH"] | None = "BOTH",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Reset vertex color for all or selected strokes

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

class _CLS_stroke_simplify(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        factor: float | None = 0.01,
        length: float | None = 0.05,
        distance: float | None = 0.01,
        steps: int | None = 1,
        mode: typing.Literal["FIXED", "ADAPTIVE", "SAMPLE", "MERGE"] | None = "FIXED",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Simplify selected strokes

                :param execution_context:
                :param undo:
                :param factor: Factor, (in [0, 100], optional)
                :param length: Length, (in [0, 100], optional)
                :param distance: Distance, (in [0, 100], optional)
                :param steps: Steps, (in [0, 50], optional)
                :param mode: Mode, Method used for simplifying stroke points (optional)

        FIXED
        Fixed -- Delete alternating vertices in the stroke, except extremes.

        ADAPTIVE
        Adaptive -- Use a Ramer-Douglas-Peucker algorithm to simplify the stroke preserving main shape.

        SAMPLE
        Sample -- Re-sample the stroke with segments of the specified length.

        MERGE
        Merge -- Simplify the stroke by merging vertices closer than a given distance.
                :return: Result of the operator call.
        """

class _CLS_stroke_smooth(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        iterations: int | None = 10,
        factor: float | None = 1.0,
        smooth_ends: bool | None = False,
        keep_shape: bool | None = False,
        smooth_position: bool | None = True,
        smooth_radius: bool | None = True,
        smooth_opacity: bool | None = False,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Smooth selected strokes

        :param execution_context:
        :param undo:
        :param iterations: Iterations, (in [1, 100], optional)
        :param factor: Factor, (in [0, 1], optional)
        :param smooth_ends: Smooth Endpoints, (optional)
        :param keep_shape: Keep Shape, (optional)
        :param smooth_position: Position, (optional)
        :param smooth_radius: Radius, (optional)
        :param smooth_opacity: Opacity, (optional)
        :return: Result of the operator call.
        """

class _CLS_stroke_split(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]]:
        """Split selected points to a new stroke

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

class _CLS_stroke_subdivide(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        number_cuts: int | None = 1,
        only_selected: bool | None = True,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Subdivide between continuous selected points of the stroke adding a point half way between them

        :param execution_context:
        :param undo:
        :param number_cuts: Number of Cuts, (in [1, 32], optional)
        :param only_selected: Selected Points, Smooth only selected points in the stroke (optional)
        :return: Result of the operator call.
        """

class _CLS_stroke_subdivide_smooth(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        GREASE_PENCIL_OT_stroke_subdivide: dict[str, typing.Any] | None = {},
        GREASE_PENCIL_OT_stroke_smooth: dict[str, typing.Any] | None = {},
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Subdivide strokes and smooth them

        :param execution_context:
        :param undo:
        :param GREASE_PENCIL_OT_stroke_subdivide: Subdivide Stroke, Subdivide between continuous selected points of the stroke adding a point half way between them (optional, `bpy.ops.grease_pencil.stroke_subdivide` keyword arguments)
        :param GREASE_PENCIL_OT_stroke_smooth: Smooth Stroke, Smooth selected strokes (optional, `bpy.ops.grease_pencil.stroke_smooth` keyword arguments)
        :return: Result of the operator call.
        """

class _CLS_stroke_switch_direction(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]]:
        """Change direction of the points of the selected strokes

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

class _CLS_stroke_trim(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        path: bpy.types.bpy_prop_collection[bpy.types.OperatorMousePath] | None = None,
        use_smooth_stroke: bool | None = False,
        smooth_stroke_factor: float | None = 0.75,
        smooth_stroke_radius: int | None = 35,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Delete stroke points in between intersecting strokes

        :param execution_context:
        :param undo:
        :param path: Path, (optional)
        :param use_smooth_stroke: Stabilize Stroke, Selection lags behind mouse and follows a smoother path (optional)
        :param smooth_stroke_factor: Smooth Stroke Factor, Higher values give a smoother stroke (in [0.5, 0.99], optional)
        :param smooth_stroke_radius: Smooth Stroke Radius, Minimum distance from last point before selection continues (in [10, 200], optional)
        :return: Result of the operator call.
        """

class _CLS_texture_gradient(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        xstart: int | None = 0,
        xend: int | None = 0,
        ystart: int | None = 0,
        yend: int | None = 0,
        flip: bool | None = False,
        cursor: int | None = 5,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Draw a line to set the fill material gradient for the selected strokes

        :param execution_context:
        :param undo:
        :param xstart: X Start, (in [-inf, inf], optional)
        :param xend: X End, (in [-inf, inf], optional)
        :param ystart: Y Start, (in [-inf, inf], optional)
        :param yend: Y End, (in [-inf, inf], optional)
        :param flip: Flip, (optional)
        :param cursor: Cursor, Mouse cursor style to use during the modal operator (in [0, inf], optional)
        :return: Result of the operator call.
        """

class _CLS_trace_image(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        target: typing.Literal["NEW", "SELECTED"] | None = "NEW",
        threshold: float | None = 0.5,
        turnpolicy: typing.Literal[
            "FOREGROUND",
            "BACKGROUND",
            "LEFT",
            "RIGHT",
            "MINORITY",
            "MAJORITY",
            "RANDOM",
        ]
        | None = "MINORITY",
        mode: typing.Literal["SINGLE", "SEQUENCE"] | None = "SINGLE",
        use_current_frame: bool | None = True,
        frame_number: int | None = 0,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Extract Grease Pencil strokes from image

                :param execution_context:
                :param undo:
                :param target: Target Object, Target Grease Pencil (optional)
                :param threshold: Color Threshold, Determine the lightness threshold above which strokes are generated (in [0, 1], optional)
                :param turnpolicy: Turn Policy, Determines how to resolve ambiguities during decomposition of bitmaps into paths (optional)

        FOREGROUND
        Foreground -- Prefers to connect foreground components.

        BACKGROUND
        Background -- Prefers to connect background components.

        LEFT
        Left -- Always take a left turn.

        RIGHT
        Right -- Always take a right turn.

        MINORITY
        Minority -- Prefers to connect the color that occurs least frequently in the local neighborhood of the current position.

        MAJORITY
        Majority -- Prefers to connect the color that occurs most frequently in the local neighborhood of the current position.

        RANDOM
        Random -- Choose pseudo-randomly.
                :param mode: Mode, Determines if trace simple image or full sequence (optional)

        SINGLE
        Single -- Trace the current frame of the image.

        SEQUENCE
        Sequence -- Trace full sequence.
                :param use_current_frame: Start At Current Frame, Trace Image starting in current image frame (optional)
                :param frame_number: Trace Frame, Used to trace only one frame of the image sequence, set to zero to trace all (in [0, 9999], optional)
                :return: Result of the operator call.
        """

class _CLS_vertex_brush_stroke(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,
        mode: typing.Literal["NORMAL", "INVERT"] | None = "NORMAL",
        brush_toggle: typing.Literal["None", "SMOOTH", "ERASE", "MASK"] | None = "None",
        pen_flip: bool | None = False,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Draw on vertex colors in the active Grease Pencil object

                :param execution_context:
                :param undo:
                :param stroke: Stroke, (optional)
                :param mode: Stroke Mode, Action taken when a paint stroke is made (optional)

        NORMAL
        Regular -- Apply brush normally.

        INVERT
        Invert -- Invert action of brush for duration of stroke.
                :param brush_toggle: Temporary Brush Toggle Type, Brush to use for duration of stroke (optional)

        None
        None -- Apply brush normally.

        SMOOTH
        Smooth -- Switch to smooth brush for duration of stroke.

        ERASE
        Erase -- Switch to erase brush for duration of stroke.

        MASK
        Mask -- Switch to mask brush for duration of stroke.
                :param pen_flip: Pen Flip, Whether a tablets eraser mode is being used (optional)
                :return: Result of the operator call.
        """

class _CLS_vertex_color_brightness_contrast(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        mode: typing.Literal["STROKE", "FILL", "BOTH"] | None = "BOTH",
        brightness: float | None = 0.0,
        contrast: float | None = 0.0,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Adjust vertex color brightness/contrast

        :param execution_context:
        :param undo:
        :param mode: Mode, (optional)
        :param brightness: Brightness, (in [-1, 1], optional)
        :param contrast: Contrast, (in [-1, 1], optional)
        :return: Result of the operator call.
        """

class _CLS_vertex_color_hsv(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        mode: typing.Literal["STROKE", "FILL", "BOTH"] | None = "BOTH",
        h: float | None = 0.5,
        s: float | None = 1.0,
        v: float | None = 1.0,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Adjust vertex color HSV values

        :param execution_context:
        :param undo:
        :param mode: Mode, (optional)
        :param h: Hue, (in [0, 1], optional)
        :param s: Saturation, (in [0, 2], optional)
        :param v: Value, (in [0, 2], optional)
        :return: Result of the operator call.
        """

class _CLS_vertex_color_invert(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        mode: typing.Literal["STROKE", "FILL", "BOTH"] | None = "BOTH",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Invert RGB values

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

class _CLS_vertex_color_levels(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        mode: typing.Literal["STROKE", "FILL", "BOTH"] | None = "BOTH",
        offset: float | None = 0.0,
        gain: float | None = 1.0,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Adjust levels of vertex colors

        :param execution_context:
        :param undo:
        :param mode: Mode, (optional)
        :param offset: Offset, Value to add to colors (in [-1, 1], optional)
        :param gain: Gain, Value to multiply colors by (in [0, inf], optional)
        :return: Result of the operator call.
        """

class _CLS_vertex_color_set(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        mode: typing.Literal["STROKE", "FILL", "BOTH"] | None = "BOTH",
        factor: float | None = 1.0,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Set active color to all selected vertices

        :param execution_context:
        :param undo:
        :param mode: Mode, (optional)
        :param factor: Factor, Mix Factor (in [0, 1], optional)
        :return: Result of the operator call.
        """

class _CLS_vertex_group_normalize(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]]:
        """Normalize weights of the active vertex group

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

class _CLS_vertex_group_normalize_all(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        lock_active: bool | None = True,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Normalize the weights of all vertex groups, so that for each vertex, the sum of all weights is 1.0

        :param execution_context:
        :param undo:
        :param lock_active: Lock Active, Keep the values of the active group while normalizing others (optional)
        :return: Result of the operator call.
        """

class _CLS_vertex_group_smooth(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        factor: float | None = 0.5,
        repeat: int | None = 1,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Smooth the weights of the active vertex group

        :param execution_context:
        :param undo:
        :param factor: Factor, (in [0, 1], optional)
        :param repeat: Iterations, (in [1, 10000], optional)
        :return: Result of the operator call.
        """

class _CLS_vertexmode_toggle(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        back: bool | None = False,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Enter/Exit vertex paint mode for Grease Pencil strokes

        :param execution_context:
        :param undo:
        :param back: Return to Previous Mode, Return to previous mode (optional)
        :return: Result of the operator call.
        """

class _CLS_weight_brush_stroke(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,
        mode: typing.Literal["NORMAL", "INVERT"] | None = "NORMAL",
        brush_toggle: typing.Literal["None", "SMOOTH", "ERASE", "MASK"] | None = "None",
        pen_flip: bool | None = False,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Draw weight on stroke points in the active Grease Pencil object

                :param execution_context:
                :param undo:
                :param stroke: Stroke, (optional)
                :param mode: Stroke Mode, Action taken when a paint stroke is made (optional)

        NORMAL
        Regular -- Apply brush normally.

        INVERT
        Invert -- Invert action of brush for duration of stroke.
                :param brush_toggle: Temporary Brush Toggle Type, Brush to use for duration of stroke (optional)

        None
        None -- Apply brush normally.

        SMOOTH
        Smooth -- Switch to smooth brush for duration of stroke.

        ERASE
        Erase -- Switch to erase brush for duration of stroke.

        MASK
        Mask -- Switch to mask brush for duration of stroke.
                :param pen_flip: Pen Flip, Whether a tablets eraser mode is being used (optional)
                :return: Result of the operator call.
        """

class _CLS_weight_invert(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]]:
        """Invert the weight of active vertex group

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

class _CLS_weight_sample(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]]:
        """Set the weight of the Draw tool to the weight of the vertex under the mouse cursor

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

class _CLS_weight_toggle_direction(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 Add/Subtract for the weight paint draw tool

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

class _CLS_weightmode_toggle(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        back: bool | None = False,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Enter/Exit weight paint mode for Grease Pencil strokes

        :param execution_context:
        :param undo:
        :param back: Return to Previous Mode, Return to previous mode (optional)
        :return: Result of the operator call.
        """

active_frame_delete: _CLS_active_frame_delete | None

bake_grease_pencil_animation: _CLS_bake_grease_pencil_animation

brush_stroke: _CLS_brush_stroke

caps_set: _CLS_caps_set

clean_loose: _CLS_clean_loose

convert_curve_type: _CLS_convert_curve_type

copy: _CLS_copy

cyclical_set: _CLS_cyclical_set

delete: _CLS_delete

delete_breakdown: _CLS_delete_breakdown

delete_frame: _CLS_delete_frame

dissolve: _CLS_dissolve

duplicate: _CLS_duplicate

duplicate_move: _CLS_duplicate_move

erase_box: _CLS_erase_box

erase_lasso: _CLS_erase_lasso

extrude: _CLS_extrude

extrude_move: _CLS_extrude_move

fill: _CLS_fill

frame_clean_duplicate: _CLS_frame_clean_duplicate

frame_duplicate: _CLS_frame_duplicate

insert_blank_frame: _CLS_insert_blank_frame

interpolate: _CLS_interpolate

interpolate_sequence: _CLS_interpolate_sequence

join_fills: _CLS_join_fills

join_selection: _CLS_join_selection

layer_active: _CLS_layer_active

layer_add: _CLS_layer_add

layer_duplicate: _CLS_layer_duplicate

layer_duplicate_object: _CLS_layer_duplicate_object

layer_group_add: _CLS_layer_group_add

layer_group_color_tag: _CLS_layer_group_color_tag

layer_group_remove: _CLS_layer_group_remove

layer_hide: _CLS_layer_hide

layer_isolate: _CLS_layer_isolate

layer_lock_all: _CLS_layer_lock_all

layer_mask_add: _CLS_layer_mask_add

layer_mask_remove: _CLS_layer_mask_remove

layer_mask_reorder: _CLS_layer_mask_reorder

layer_merge: _CLS_layer_merge

layer_move: _CLS_layer_move

layer_remove: _CLS_layer_remove

layer_reveal: _CLS_layer_reveal

material_copy_to_object: _CLS_material_copy_to_object

material_hide: _CLS_material_hide

material_isolate: _CLS_material_isolate

material_lock_all: _CLS_material_lock_all

material_lock_unselected: _CLS_material_lock_unselected

material_lock_unused: _CLS_material_lock_unused

material_reveal: _CLS_material_reveal

material_select: _CLS_material_select

material_unlock_all: _CLS_material_unlock_all

move_to_layer: _CLS_move_to_layer

outline: _CLS_outline

paintmode_toggle: _CLS_paintmode_toggle

paste: _CLS_paste

pen: _CLS_pen

primitive_arc: _CLS_primitive_arc

primitive_box: _CLS_primitive_box

primitive_circle: _CLS_primitive_circle

primitive_curve: _CLS_primitive_curve

primitive_line: _CLS_primitive_line

primitive_polyline: _CLS_primitive_polyline

relative_layer_mask_add: _CLS_relative_layer_mask_add

remove_fill_guides: _CLS_remove_fill_guides

reorder: _CLS_reorder

reproject: _CLS_reproject

reset_uvs: _CLS_reset_uvs

sculpt_paint: _CLS_sculpt_paint

sculptmode_toggle: _CLS_sculptmode_toggle

select_all: _CLS_select_all

select_alternate: _CLS_select_alternate

select_by_stroke_type: _CLS_select_by_stroke_type

select_ends: _CLS_select_ends

select_fill: _CLS_select_fill

select_less: _CLS_select_less

select_linked: _CLS_select_linked

select_more: _CLS_select_more

select_random: _CLS_select_random

select_similar: _CLS_select_similar

separate: _CLS_separate

separate_fills: _CLS_separate_fills

set_active_material: _CLS_set_active_material

set_corner_type: _CLS_set_corner_type

set_curve_resolution: _CLS_set_curve_resolution

set_curve_type: _CLS_set_curve_type

set_handle_type: _CLS_set_handle_type

set_material: _CLS_set_material

set_selection_mode: _CLS_set_selection_mode

set_start_point: _CLS_set_start_point

set_stroke_type: _CLS_set_stroke_type

set_uniform_opacity: _CLS_set_uniform_opacity

set_uniform_thickness: _CLS_set_uniform_thickness

snap_cursor_to_selected: _CLS_snap_cursor_to_selected

snap_to_cursor: _CLS_snap_to_cursor

snap_to_grid: _CLS_snap_to_grid

stroke_material_set: _CLS_stroke_material_set

stroke_merge_by_distance: _CLS_stroke_merge_by_distance

stroke_reset_vertex_color: _CLS_stroke_reset_vertex_color

stroke_simplify: _CLS_stroke_simplify

stroke_smooth: _CLS_stroke_smooth

stroke_split: _CLS_stroke_split

stroke_subdivide: _CLS_stroke_subdivide

stroke_subdivide_smooth: _CLS_stroke_subdivide_smooth

stroke_switch_direction: _CLS_stroke_switch_direction

stroke_trim: _CLS_stroke_trim

texture_gradient: _CLS_texture_gradient

trace_image: _CLS_trace_image

vertex_brush_stroke: _CLS_vertex_brush_stroke

vertex_color_brightness_contrast: _CLS_vertex_color_brightness_contrast

vertex_color_hsv: _CLS_vertex_color_hsv

vertex_color_invert: _CLS_vertex_color_invert

vertex_color_levels: _CLS_vertex_color_levels

vertex_color_set: _CLS_vertex_color_set

vertex_group_normalize: _CLS_vertex_group_normalize

vertex_group_normalize_all: _CLS_vertex_group_normalize_all

vertex_group_smooth: _CLS_vertex_group_smooth

vertexmode_toggle: _CLS_vertexmode_toggle

weight_brush_stroke: _CLS_weight_brush_stroke

weight_invert: _CLS_weight_invert

weight_sample: _CLS_weight_sample

weight_toggle_direction: _CLS_weight_toggle_direction

weightmode_toggle: _CLS_weightmode_toggle
