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

class _CLS_actionzone(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        modifier: int | None = 0,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Handle area action zones for mouse actions/gestures

        :param execution_context:
        :param undo:
        :param modifier: Modifier, Modifier state (in [0, 2], optional)
        :return: Result of the operator call.
        """

class _CLS_animation_cancel(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        restore_frame: bool | None = True,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Cancel animation, returning to the original frame

        :param execution_context:
        :param undo:
        :param restore_frame: Restore Frame, Restore the frame when animation was initialized (optional)
        :return: Result of the operator call.
        """

class _CLS_animation_play(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        reverse: bool | None = False,
        sync: bool | None = False,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Play animation

        :param execution_context:
        :param undo:
        :param reverse: Play in Reverse, Animation is played backwards (optional)
        :param sync: Sync, Drop frames to maintain framerate (optional)
        :return: Result of the operator call.
        """

class _CLS_animation_step(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]]:
        """Step through animation by position

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

class _CLS_area_close(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]]:
        """Close selected area

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

class _CLS_area_dupli(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 selected area into new window

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

class _CLS_area_join(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        source_xy: collections.abc.Sequence[int] | None = (0, 0),
        target_xy: collections.abc.Sequence[int] | None = (0, 0),
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Join selected areas into new window

        :param execution_context:
        :param undo:
        :param source_xy: Source location, (array of 2 items, in [-inf, inf], optional)
        :param target_xy: Target location, (array of 2 items, in [-inf, inf], optional)
        :return: Result of the operator call.
        """

class _CLS_area_move(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        x: int | None = 0,
        y: int | None = 0,
        delta: int | None = 0,
        snap: bool | None = False,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Move selected area edges

        :param execution_context:
        :param undo:
        :param x: X, (in [-inf, inf], optional)
        :param y: Y, (in [-inf, inf], optional)
        :param delta: Delta, (in [-inf, inf], optional)
        :param snap: Snapping, Enable snapping (optional)
        :return: Result of the operator call.
        """

class _CLS_area_options(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]]:
        """Operations for splitting and merging

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

class _CLS_area_split(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        direction: typing.Literal["HORIZONTAL", "VERTICAL"] | None = "HORIZONTAL",
        factor: float | None = 0.5,
        cursor: collections.abc.Sequence[int] | None = (0, 0),
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Split selected area into new windows

        :param execution_context:
        :param undo:
        :param direction: Direction, (optional)
        :param factor: Factor, (in [0, 1], optional)
        :param cursor: Cursor, (array of 2 items, in [-inf, inf], optional)
        :return: Result of the operator call.
        """

class _CLS_area_swap(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        cursor: collections.abc.Sequence[int] | None = (0, 0),
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Swap selected areas screen positions

        :param execution_context:
        :param undo:
        :param cursor: Cursor, (array of 2 items, in [-inf, inf], optional)
        :return: Result of the operator call.
        """

class _CLS_back_to_previous(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]]:
        """Revert back to the original screen layout, before fullscreen area overlay

        :param execution_context:
        :param undo:
        :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,
        /,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Delete active screen

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

class _CLS_drivers_editor_show(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 drivers editor in a separate window

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

class _CLS_frame_jump(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        end: bool | None = False,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Jump to first/last frame in frame range

        :param execution_context:
        :param undo:
        :param end: Last Frame, Jump to the last frame of the frame range (optional)
        :return: Result of the operator call.
        """

class _CLS_frame_offset(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        delta: int | None = 0,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Move current frame forward/backward by a given number

        :param execution_context:
        :param undo:
        :param delta: Delta, (in [-inf, inf], optional)
        :return: Result of the operator call.
        """

class _CLS_header_toggle_menus(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]]:
        """Expand or collapse the header pull-down menus

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

class _CLS_info_log_show(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 info log in a separate window

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

class _CLS_keyframe_jump(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        next: bool | None = True,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Jump to previous/next keyframe

        :param execution_context:
        :param undo:
        :param next: Next Keyframe, (optional)
        :return: Result of the operator call.
        """

class _CLS_marker_jump(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        next: bool | None = True,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Jump to previous/next marker

        :param execution_context:
        :param undo:
        :param next: Next Marker, (optional)
        :return: Result of the operator call.
        """

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

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

class _CLS_quadview_size(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]]:
        """Resize Quad View areas

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

class _CLS_redo_last(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]]:
        """Display parameters for last action performed

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

class _CLS_region_blend(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]]:
        """Blend in and out overlapping region

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

class _CLS_region_context_menu(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]]:
        """Display region context menu

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

class _CLS_region_flip(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 the regions alignment (left/right or top/bottom)

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

class _CLS_region_quadview(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 area into camera, front, right, and top views

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

class _CLS_region_scale(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]]:
        """Scale selected area

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

class _CLS_region_toggle(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        region_type: typing.Literal[bpy.stub_internal.rna_enums.RegionTypeItems]
        | None = "WINDOW",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Hide or unhide the region

        :param execution_context:
        :param undo:
        :param region_type: Region Type, Type of the region to toggle (optional)
        :return: Result of the operator call.
        """

class _CLS_repeat_history(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        index: int | None = 0,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Display menu for previous actions performed

        :param execution_context:
        :param undo:
        :param index: Index, (in [0, inf], optional)
        :return: Result of the operator call.
        """

class _CLS_repeat_last(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]]:
        """Repeat last action

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

class _CLS_screen_full_area(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        use_hide_panels: bool | None = False,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Toggle display selected area as fullscreen/maximized

        :param execution_context:
        :param undo:
        :param use_hide_panels: Hide Panels, Hide all the panels (Focus Mode) (optional)
        :return: Result of the operator call.
        """

class _CLS_screen_set(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        delta: int | None = 1,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Cycle through available screens

        :param execution_context:
        :param undo:
        :param delta: Delta, (in [-1, 1], optional)
        :return: Result of the operator call.
        """

class _CLS_screenshot(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        filepath: str = "",
        hide_props_region: bool | None = True,
        check_existing: bool | None = True,
        filter_blender: bool | None = False,
        filter_backup: bool | None = False,
        filter_image: bool | None = True,
        filter_movie: bool | None = False,
        filter_python: bool | None = False,
        filter_font: bool | None = False,
        filter_sound: bool | None = False,
        filter_text: bool | None = False,
        filter_archive: bool | None = False,
        filter_btx: bool | None = False,
        filter_alembic: bool | None = False,
        filter_usd: bool | None = False,
        filter_obj: bool | None = False,
        filter_volume: bool | None = False,
        filter_folder: bool | None = True,
        filter_blenlib: bool | None = False,
        filemode: int | None = 9,
        show_multiview: bool | None = False,
        use_multiview: bool | None = False,
        display_type: typing.Literal[
            "DEFAULT", "LIST_VERTICAL", "LIST_HORIZONTAL", "THUMBNAIL"
        ]
        | None = "DEFAULT",
        sort_method: str | None = "",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Capture a picture of the whole Blender window

                :param execution_context:
                :param undo:
                :param filepath: File Path, Path to file (optional, never None)
                :param hide_props_region: Hide Operator Properties, Collapse the region displaying the operator settings (optional)
                :param check_existing: Check Existing, Check and warn on overwriting existing files (optional)
                :param filter_blender: Filter .blend files, (optional)
                :param filter_backup: Filter backup .blend files, (optional)
                :param filter_image: Filter image files, (optional)
                :param filter_movie: Filter movie files, (optional)
                :param filter_python: Filter Python files, (optional)
                :param filter_font: Filter font files, (optional)
                :param filter_sound: Filter sound files, (optional)
                :param filter_text: Filter text files, (optional)
                :param filter_archive: Filter archive files, (optional)
                :param filter_btx: Filter btx files, (optional)
                :param filter_alembic: Filter Alembic files, (optional)
                :param filter_usd: Filter USD files, (optional)
                :param filter_obj: Filter OBJ files, (optional)
                :param filter_volume: Filter OpenVDB volume files, (optional)
                :param filter_folder: Filter folders, (optional)
                :param filter_blenlib: Filter Blender IDs, (optional)
                :param filemode: File Browser Mode, The setting for the file browser mode to load a .blend file, a library or a special file (in [1, 9], optional)
                :param show_multiview: Enable Multi-View, (optional)
                :param use_multiview: Use Multi-View, (optional)
                :param display_type: Display Type, (optional)

        DEFAULT
        Default -- Automatically determine display type for files.

        LIST_VERTICAL
        Short List -- Display files as short list.

        LIST_HORIZONTAL
        Long List -- Display files as a detailed list.

        THUMBNAIL
        Thumbnails -- Display files as thumbnails.
                :param sort_method: File sorting mode, (optional)
                :return: Result of the operator call.
        """

class _CLS_screenshot_area(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        filepath: str = "",
        hide_props_region: bool | None = True,
        check_existing: bool | None = True,
        filter_blender: bool | None = False,
        filter_backup: bool | None = False,
        filter_image: bool | None = True,
        filter_movie: bool | None = False,
        filter_python: bool | None = False,
        filter_font: bool | None = False,
        filter_sound: bool | None = False,
        filter_text: bool | None = False,
        filter_archive: bool | None = False,
        filter_btx: bool | None = False,
        filter_alembic: bool | None = False,
        filter_usd: bool | None = False,
        filter_obj: bool | None = False,
        filter_volume: bool | None = False,
        filter_folder: bool | None = True,
        filter_blenlib: bool | None = False,
        filemode: int | None = 9,
        show_multiview: bool | None = False,
        use_multiview: bool | None = False,
        display_type: typing.Literal[
            "DEFAULT", "LIST_VERTICAL", "LIST_HORIZONTAL", "THUMBNAIL"
        ]
        | None = "DEFAULT",
        sort_method: str | None = "",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Capture a picture of an editor

                :param execution_context:
                :param undo:
                :param filepath: File Path, Path to file (optional, never None)
                :param hide_props_region: Hide Operator Properties, Collapse the region displaying the operator settings (optional)
                :param check_existing: Check Existing, Check and warn on overwriting existing files (optional)
                :param filter_blender: Filter .blend files, (optional)
                :param filter_backup: Filter backup .blend files, (optional)
                :param filter_image: Filter image files, (optional)
                :param filter_movie: Filter movie files, (optional)
                :param filter_python: Filter Python files, (optional)
                :param filter_font: Filter font files, (optional)
                :param filter_sound: Filter sound files, (optional)
                :param filter_text: Filter text files, (optional)
                :param filter_archive: Filter archive files, (optional)
                :param filter_btx: Filter btx files, (optional)
                :param filter_alembic: Filter Alembic files, (optional)
                :param filter_usd: Filter USD files, (optional)
                :param filter_obj: Filter OBJ files, (optional)
                :param filter_volume: Filter OpenVDB volume files, (optional)
                :param filter_folder: Filter folders, (optional)
                :param filter_blenlib: Filter Blender IDs, (optional)
                :param filemode: File Browser Mode, The setting for the file browser mode to load a .blend file, a library or a special file (in [1, 9], optional)
                :param show_multiview: Enable Multi-View, (optional)
                :param use_multiview: Use Multi-View, (optional)
                :param display_type: Display Type, (optional)

        DEFAULT
        Default -- Automatically determine display type for files.

        LIST_VERTICAL
        Short List -- Display files as short list.

        LIST_HORIZONTAL
        Long List -- Display files as a detailed list.

        THUMBNAIL
        Thumbnails -- Display files as thumbnails.
                :param sort_method: File sorting mode, (optional)
                :return: Result of the operator call.
        """

class _CLS_space_context_cycle(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        direction: typing.Literal["PREV", "NEXT"] | None = "NEXT",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Cycle through the editor context by activating the next/previous one

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

class _CLS_space_type_set_or_cycle(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        space_type: typing.Literal[bpy.stub_internal.rna_enums.SpaceTypeItems]
        | None = "EMPTY",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Set the space type or cycle subtype

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

class _CLS_spacedata_cleanup(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 unused settings for invisible editors

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

class _CLS_time_jump(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        backward: bool | None = False,
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Jump forward/backward by a given number of frames or seconds

        :param execution_context:
        :param undo:
        :param backward: Backwards, Jump backwards in time (optional)
        :return: Result of the operator call.
        """

class _CLS_userpref_show(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        section: typing.Literal[bpy.stub_internal.rna_enums.PreferenceSectionItems]
        | None = "INTERFACE",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Edit user preferences and system settings

        :param execution_context:
        :param undo:
        :param section: Section to activate in the Preferences (optional)
        :return: Result of the operator call.
        """

class _CLS_workspace_cycle(bpy.ops._BPyOpsSubModOp):
    def __call__(
        self,
        execution_context: int | str | None = None,
        undo: bool | None = None,
        /,
        *,
        direction: typing.Literal["PREV", "NEXT"] | None = "NEXT",
    ) -> set[typing.Literal[bpy.stub_internal.rna_enums.OperatorReturnItems]]:
        """Cycle through workspaces

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

actionzone: _CLS_actionzone

animation_cancel: _CLS_animation_cancel

animation_play: _CLS_animation_play

animation_step: _CLS_animation_step

area_close: _CLS_area_close

area_dupli: _CLS_area_dupli

area_join: _CLS_area_join

area_move: _CLS_area_move

area_options: _CLS_area_options

area_split: _CLS_area_split

area_swap: _CLS_area_swap

back_to_previous: _CLS_back_to_previous

delete: _CLS_delete

drivers_editor_show: _CLS_drivers_editor_show

frame_jump: _CLS_frame_jump

frame_offset: _CLS_frame_offset

header_toggle_menus: _CLS_header_toggle_menus

info_log_show: _CLS_info_log_show

keyframe_jump: _CLS_keyframe_jump

marker_jump: _CLS_marker_jump

new: _CLS_new

quadview_size: _CLS_quadview_size

redo_last: _CLS_redo_last

region_blend: _CLS_region_blend

region_context_menu: _CLS_region_context_menu

region_flip: _CLS_region_flip

region_quadview: _CLS_region_quadview

region_scale: _CLS_region_scale

region_toggle: _CLS_region_toggle

repeat_history: _CLS_repeat_history

repeat_last: _CLS_repeat_last

screen_full_area: _CLS_screen_full_area

screen_set: _CLS_screen_set

screenshot: _CLS_screenshot

screenshot_area: _CLS_screenshot_area

space_context_cycle: _CLS_space_context_cycle

space_type_set_or_cycle: _CLS_space_type_set_or_cycle

spacedata_cleanup: _CLS_spacedata_cleanup

time_jump: _CLS_time_jump

userpref_show: _CLS_userpref_show

workspace_cycle: _CLS_workspace_cycle
