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

class _CLS_change_frame(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        frame: float | None = 0.0,
        snap: bool | None = False,
        seq_solo_preview: bool | None = False,
        pass_through_on_strip_handles: bool | None = False,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Interactively change the current frame number

        :param execution_context:
        :param undo:
        :param frame: Frame, (in [-1.04857e+06, 1.04857e+06], optional)
        :param snap: Snap, (optional)
        :param seq_solo_preview: Strip Preview, (optional)
        :param pass_through_on_strip_handles: Pass Through on Strip Handles, Allow another operator to operate on strip handles (optional)
        :return: Result of the operator call.
        """

class _CLS_channel_select_keys(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        extend: bool | None = False,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Select all keyframes of channel under mouse

        :param execution_context:
        :param undo:
        :param extend: Extend, Extend selection (optional)
        :return: Result of the operator call.
        """

class _CLS_channel_view_pick(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        include_handles: bool | None = True,
        use_preview_range: bool | None = True,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Reset viewable area to show the channel under the cursor

        :param execution_context:
        :param undo:
        :param include_handles: Include Handles, Include handles of keyframes when calculating extents (optional)
        :param use_preview_range: Use Preview Range, Ignore frames outside of the preview range (optional)
        :return: Result of the operator call.
        """

class _CLS_channels_bake(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        use_scene_range: bool | None = True,
        range: collections.abc.Sequence[int] | None = (0, 0),
        step: float | None = 1.0,
        remove_outside_range: bool | None = False,
        interpolation_type: typing.Literal["BEZIER", "LIN", "CONST"] | None = "BEZIER",
        bake_modifiers: bool | None = True,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Create keyframes following the current shape of F-Curves of selected channels

                :param execution_context:
                :param undo:
                :param use_scene_range: Use Scene Range, If enabled, the scene start and end frame will be used to determine the bake range (optional)
                :param range: Frame Range, The custom range in which to create new keys. Only used when not using the scene range (array of 2 items, in [-inf, inf], optional)
                :param step: Frame Step, At which interval to add keys (in [0.01, inf], optional)
                :param remove_outside_range: Remove Outside Range, Removes keys outside the given range, leaving only the newly baked (optional)
                :param interpolation_type: Interpolation Type, Choose the interpolation type with which new keys will be added (optional)

        BEZIER
        Bézier -- New keys will be Bézier.

        LIN
        Linear -- New keys will be linear.

        CONST
        Constant -- New keys will be constant.
                :param bake_modifiers: Bake Modifiers, Bake Modifiers into keyframes and delete them after (optional)
                :return: Result of the operator call.
        """

class _CLS_channels_clean_empty(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]]:
        """Delete all empty animation data containers from visible data-blocks

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

class _CLS_channels_click(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        extend: bool | None = False,
        extend_range: bool | None = False,
        children_only: bool | None = False,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Handle mouse clicks over animation channels

        :param execution_context:
        :param undo:
        :param extend: Extend Select, (optional)
        :param extend_range: Extend Range, Selection of active channel to clicked channel (optional)
        :param children_only: Select Children Only, (optional)
        :return: Result of the operator call.
        """

class _CLS_channels_collapse(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        all: bool | None = True,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Collapse (close) all selected expandable animation channels

        :param execution_context:
        :param undo:
        :param all: All, Collapse all channels (not just selected ones) (optional)
        :return: Result of the operator call.
        """

class _CLS_channels_delete(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]]:
        """Delete all selected animation channels

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

class _CLS_channels_editable_toggle(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        mode: typing.Literal["TOGGLE", "DISABLE", "ENABLE", "INVERT"] | None = "TOGGLE",
        type: typing.Literal["PROTECT", "MUTE"] | None = "PROTECT",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Toggle editability of selected channels

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

class _CLS_channels_expand(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        all: bool | None = True,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Expand (open) all selected expandable animation channels

        :param execution_context:
        :param undo:
        :param all: All, Expand all channels (not just selected ones) (optional)
        :return: Result of the operator call.
        """

class _CLS_channels_fcurves_enable(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]]:
        """Clear disabled tag from all F-Curves to get broken F-Curves working again

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

class _CLS_channels_group(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 selected F-Curves to a new group

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

class _CLS_channels_move(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        direction: typing.Literal["TOP", "UP", "DOWN", "BOTTOM"] | None = "DOWN",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Rearrange selected animation channels

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

class _CLS_channels_rename(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]]:
        """Rename animation channel under mouse

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

class _CLS_channels_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]]:
        """Toggle selection of all animation channels

                :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_channels_select_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,
        deselect: bool | None = False,
        extend: bool | None = True,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Select all animation channels within the specified 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)
        :param deselect: Deselect, Deselect rather than select items (optional)
        :param extend: Extend, Extend selection instead of deselecting everything first (optional)
        :return: Result of the operator call.
        """

class _CLS_channels_select_filter(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]]:
        """Start entering text which filters the set of channels shown to only include those with matching names

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

class _CLS_channels_setting_disable(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        mode: typing.Literal["TOGGLE", "DISABLE", "ENABLE", "INVERT"]
        | None = "DISABLE",
        type: typing.Literal["PROTECT", "MUTE"] | None = "PROTECT",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Disable specified setting on all selected animation channels

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

class _CLS_channels_setting_enable(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        mode: typing.Literal["TOGGLE", "DISABLE", "ENABLE", "INVERT"] | None = "ENABLE",
        type: typing.Literal["PROTECT", "MUTE"] | None = "PROTECT",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Enable specified setting on all selected animation channels

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

class _CLS_channels_setting_toggle(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        mode: typing.Literal["TOGGLE", "DISABLE", "ENABLE", "INVERT"] | None = "TOGGLE",
        type: typing.Literal["PROTECT", "MUTE"] | None = "PROTECT",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Toggle specified setting on all selected animation channels

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

class _CLS_channels_ungroup(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 selected F-Curves from their current groups

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

class _CLS_channels_view_selected(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        include_handles: bool | None = True,
        use_preview_range: bool | None = True,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Reset viewable area to show the selected channels

        :param execution_context:
        :param undo:
        :param include_handles: Include Handles, Include handles of keyframes when calculating extents (optional)
        :param use_preview_range: Use Preview Range, Ignore frames outside of the preview range (optional)
        :return: Result of the operator call.
        """

class _CLS_clear_useless_actions(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        only_unused: bool | None = True,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Mark actions with no F-Curves for deletion after save and reload of file preserving "action libraries"

        :param execution_context:
        :param undo:
        :param only_unused: Only Unused, Only unused (Fake User only) actions get considered (optional)
        :return: Result of the operator call.
        """

class _CLS_copy_driver_button(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 driver for the highlighted button

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

class _CLS_driver_button_add(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Add driver for the property under the cursor

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

class _CLS_driver_button_edit(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]]:
        """Edit the drivers for the connected property represented by the highlighted button

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

class _CLS_driver_button_remove(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        all: bool | None = True,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Remove the driver(s) for the connected property(s) represented by the highlighted button

        :param execution_context:
        :param undo:
        :param all: All, Delete drivers for all elements of the array (optional)
        :return: Result of the operator call.
        """

class _CLS_end_frame_set(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 current frame as the preview or scene end frame

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

class _CLS_keyframe_clear_button(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        all: bool | None = True,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Clear all keyframes on the currently active property

        :param execution_context:
        :param undo:
        :param all: All, Clear keyframes from all elements of the array (optional)
        :return: Result of the operator call.
        """

class _CLS_keyframe_clear_v3d(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        confirm: bool | None = True,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Remove all keyframe animation for selected objects

        :param execution_context:
        :param undo:
        :param confirm: Confirm, Prompt for confirmation (optional)
        :return: Result of the operator call.
        """

class _CLS_keyframe_clear_vse(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        confirm: bool | None = True,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Remove all keyframe animation for selected strips

        :param execution_context:
        :param undo:
        :param confirm: Confirm, Prompt for confirmation (optional)
        :return: Result of the operator call.
        """

class _CLS_keyframe_delete(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        type: typing.Literal["DEFAULT"] | None = "DEFAULT",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Delete keyframes on the current frame for all properties in the specified Keying Set

        :param execution_context:
        :param undo:
        :param type: Keying Set, The Keying Set to use (optional)
        :return: Result of the operator call.
        """

class _CLS_keyframe_delete_button(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        all: bool | None = True,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Delete current keyframe of current UI-active property

        :param execution_context:
        :param undo:
        :param all: All, Delete keyframes from all elements of the array (optional)
        :return: Result of the operator call.
        """

class _CLS_keyframe_delete_by_name(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        type: str = "",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Alternate access to Delete Keyframe for keymaps to use

        :param execution_context:
        :param undo:
        :param type: Keying Set, The Keying Set to use (optional, never None)
        :return: Result of the operator call.
        """

class _CLS_keyframe_delete_v3d(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        confirm: bool | None = True,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Remove keyframes on current frame for selected objects and bones

        :param execution_context:
        :param undo:
        :param confirm: Confirm, Prompt for confirmation (optional)
        :return: Result of the operator call.
        """

class _CLS_keyframe_delete_vse(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        confirm: bool | None = True,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Remove keyframes on current frame for selected strips

        :param execution_context:
        :param undo:
        :param confirm: Confirm, Prompt for confirmation (optional)
        :return: Result of the operator call.
        """

class _CLS_keyframe_insert(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        type: typing.Literal["DEFAULT"] | None = "DEFAULT",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Insert keyframes on the current frame using either the active keying set, or the user preferences if no keying set is active

        :param execution_context:
        :param undo:
        :param type: Keying Set, The Keying Set to use (optional)
        :return: Result of the operator call.
        """

class _CLS_keyframe_insert_button(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        all: bool | None = True,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Insert a keyframe for current UI-active property

        :param execution_context:
        :param undo:
        :param all: All, Insert a keyframe for all element of the array (optional)
        :return: Result of the operator call.
        """

class _CLS_keyframe_insert_by_name(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        type: str = "",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Alternate access to Insert Keyframe for keymaps to use

        :param execution_context:
        :param undo:
        :param type: Keying Set, The Keying Set to use (optional, never None)
        :return: Result of the operator call.
        """

class _CLS_keyframe_insert_menu(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        type: typing.Literal["DEFAULT"] | None = "DEFAULT",
        always_prompt: bool | None = False,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Insert Keyframes for specified Keying Set, with menu of available Keying Sets if undefined

        :param execution_context:
        :param undo:
        :param type: Keying Set, The Keying Set to use (optional)
        :param always_prompt: Always Show Menu, (optional)
        :return: Result of the operator call.
        """

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

        :param execution_context:
        :param undo:
        :param type: Keying Set, The Keying Set to use (optional)
        :return: Result of the operator call.
        """

class _CLS_keying_set_add(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Add a new (empty) keying set to the active Scene

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

class _CLS_keying_set_export(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        filepath: str = "",
        filter_folder: bool | None = True,
        filter_text: bool | None = True,
        filter_python: bool | None = True,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Export Keying Set to a Python script

        :param execution_context:
        :param undo:
        :param filepath: filepath, (optional, never None)
        :param filter_folder: Filter folders, (optional)
        :param filter_text: Filter text, (optional)
        :param filter_python: Filter Python, (optional)
        :return: Result of the operator call.
        """

class _CLS_keying_set_path_add(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Add empty path to active keying set

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

class _CLS_keying_set_path_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 active Path from active keying set

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

class _CLS_keying_set_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 keying set

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

class _CLS_keyingset_button_add(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        all: bool | None = True,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Add current UI-active property to current keying set

        :param execution_context:
        :param undo:
        :param all: All, Add all elements of the array to a Keying Set (optional)
        :return: Result of the operator call.
        """

class _CLS_keyingset_button_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 current UI-active property from current keying set

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

class _CLS_merge_animation(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]]:
        """Merge the animation of the selected objects into the action of the active object. Actions are not deleted by this, but might end up with zero users

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

class _CLS_paste_driver_button(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]]:
        """Paste the driver in the internal clipboard to the highlighted button

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

class _CLS_previewrange_clear(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Clear preview range

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

class _CLS_previewrange_set(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]]:
        """Interactively define frame range used for playback

        :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_replace_action(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        old_session_uid: int | None = 0,
        new_session_uid: int | None = 0,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Swap all users of one action to another one. The normal action slot assignment rules apply. This ignores the NLA and Action Constraints

        :param execution_context:
        :param undo:
        :param old_session_uid: Old Action, Old Actions session uid to replace (in [-inf, inf], optional)
        :param new_session_uid: Replacement Action, The replacement Actions session uid to remap all selected Actions users to (in [-inf, inf], optional)
        :return: Result of the operator call.
        """

class _CLS_replace_action_new(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        old_session_uid: int | None = 0,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Swap all users of one action to a new action. This ignores the NLA and Action Constraints

        :param execution_context:
        :param undo:
        :param old_session_uid: Old Action, Old Actions session uid to replace (in [-inf, inf], optional)
        :return: Result of the operator call.
        """

class _CLS_scene_range_frame(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 the horizontal view to the current scene frame range, taking the preview range into account if it is active

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

class _CLS_separate_slots(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Move all slots of the action on the active object into newly created, separate actions. All users of those slots will be reassigned to the new actions. The current action wont be deleted but will be empty and might end up having zero users

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

class _CLS_slot_channels_move_to_new_action(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Move the selected slots into a newly created action

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

class _CLS_slot_new_for_id(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]]:
        """Create a new action slot for this data-block, to hold its animation

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

class _CLS_slot_unassign_from_constraint(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]]:
        """Un-assign the action slot from this constraint

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

class _CLS_slot_unassign_from_id(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]]:
        """Un-assign the action slot, effectively making this data-block non-animated

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

class _CLS_slot_unassign_from_nla_strip(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]]:
        """Un-assign the action slot from this NLA strip, effectively making it non-animated

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

class _CLS_start_frame_set(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 current frame as the preview or scene start frame

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

class _CLS_update_animated_transform_constraints(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        use_convert_to_radians: bool | None = True,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Update f-curves/drivers affecting Transform constraints (use it with files from 2.70 and earlier)

        :param execution_context:
        :param undo:
        :param use_convert_to_radians: Convert to Radians, Convert f-curves/drivers affecting rotations to radians.Warning: Use this only once(optional)
        :return: Result of the operator call.
        """

class _CLS_version_bone_hide_property(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]]:
        """Moves any F-Curves for the hide property of selected armatures into the action of the object. This will only operate on the first layer and strip of the action

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

class _CLS_view_curve_in_graph_editor(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        all: bool | None = False,
        isolate: bool | None = False,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Frame the property under the cursor in the Graph Editor

        :param execution_context:
        :param undo:
        :param all: Show All, Frame the whole array property instead of only the index under the cursor (optional)
        :param isolate: Isolate, Hides all F-Curves other than the ones being framed (optional)
        :return: Result of the operator call.
        """

change_frame: _CLS_change_frame

channel_select_keys: _CLS_channel_select_keys

channel_view_pick: _CLS_channel_view_pick

channels_bake: _CLS_channels_bake

channels_clean_empty: _CLS_channels_clean_empty

channels_click: _CLS_channels_click

channels_collapse: _CLS_channels_collapse

channels_delete: _CLS_channels_delete

channels_editable_toggle: _CLS_channels_editable_toggle

channels_expand: _CLS_channels_expand

channels_fcurves_enable: _CLS_channels_fcurves_enable

channels_group: _CLS_channels_group

channels_move: _CLS_channels_move

channels_rename: _CLS_channels_rename

channels_select_all: _CLS_channels_select_all

channels_select_box: _CLS_channels_select_box

channels_select_filter: _CLS_channels_select_filter

channels_setting_disable: _CLS_channels_setting_disable

channels_setting_enable: _CLS_channels_setting_enable

channels_setting_toggle: _CLS_channels_setting_toggle

channels_ungroup: _CLS_channels_ungroup

channels_view_selected: _CLS_channels_view_selected

clear_useless_actions: _CLS_clear_useless_actions

copy_driver_button: _CLS_copy_driver_button

driver_button_add: _CLS_driver_button_add

driver_button_edit: _CLS_driver_button_edit

driver_button_remove: _CLS_driver_button_remove

end_frame_set: _CLS_end_frame_set

keyframe_clear_button: _CLS_keyframe_clear_button

keyframe_clear_v3d: _CLS_keyframe_clear_v3d

keyframe_clear_vse: _CLS_keyframe_clear_vse

keyframe_delete: _CLS_keyframe_delete

keyframe_delete_button: _CLS_keyframe_delete_button

keyframe_delete_by_name: _CLS_keyframe_delete_by_name

keyframe_delete_v3d: _CLS_keyframe_delete_v3d

keyframe_delete_vse: _CLS_keyframe_delete_vse

keyframe_insert: _CLS_keyframe_insert

keyframe_insert_button: _CLS_keyframe_insert_button

keyframe_insert_by_name: _CLS_keyframe_insert_by_name

keyframe_insert_menu: _CLS_keyframe_insert_menu

keying_set_active_set: _CLS_keying_set_active_set

keying_set_add: _CLS_keying_set_add

keying_set_export: _CLS_keying_set_export

keying_set_path_add: _CLS_keying_set_path_add

keying_set_path_remove: _CLS_keying_set_path_remove

keying_set_remove: _CLS_keying_set_remove

keyingset_button_add: _CLS_keyingset_button_add

keyingset_button_remove: _CLS_keyingset_button_remove

merge_animation: _CLS_merge_animation

paste_driver_button: _CLS_paste_driver_button

previewrange_clear: _CLS_previewrange_clear

previewrange_set: _CLS_previewrange_set

replace_action: _CLS_replace_action

replace_action_new: _CLS_replace_action_new

scene_range_frame: _CLS_scene_range_frame

separate_slots: _CLS_separate_slots

slot_channels_move_to_new_action: _CLS_slot_channels_move_to_new_action

slot_new_for_id: _CLS_slot_new_for_id

slot_unassign_from_constraint: _CLS_slot_unassign_from_constraint

slot_unassign_from_id: _CLS_slot_unassign_from_id

slot_unassign_from_nla_strip: _CLS_slot_unassign_from_nla_strip

start_frame_set: _CLS_start_frame_set

update_animated_transform_constraints: _CLS_update_animated_transform_constraints

version_bone_hide_property: _CLS_version_bone_hide_property

view_curve_in_graph_editor: _CLS_view_curve_in_graph_editor
