user: Provide the full official documentation entry for Mesh Operators, preserving all code examples.

assistant: .ops.mesh.duplicate_move(*\**, *MESH_OT_duplicate=None*, *TRANSFORM_OT_translate=None*)
:   Duplicate mesh and move

    Parameters:
    :   - **MESH_OT_duplicate** (`MESH_OT_duplicate`, (optional)) – Duplicate, Duplicate selected vertices, edges or faces
        - **TRANSFORM_OT_translate** (`TRANSFORM_OT_translate`, (optional)) – Move, Move selected items

bpy.ops.mesh.edge_collapse()
:   Collapse isolated edge and face regions, merging data such as UVs and color attributes. This can collapse edge-rings as well as regions of connected faces into vertices

bpy.ops.mesh.edge_face_add()
:   Add an edge or face to selected

bpy.ops.mesh.edge_rotate(*\**, *use_ccw=False*)
:   Rotate selected edge or adjoining faces

    Parameters:
    :   **use_ccw** (*boolean**,* *(**optional**)*) – Counter Clockwise

bpy.ops.mesh.edge_split(*\**, *type='EDGE'*)
:   Split selected edges so that each neighbor face gets its own copy

    Parameters:
    :   **type** (enum in [`'EDGE'`, `'VERT'`], (optional)) –

        Type, Method to use for splitting

        - `EDGE`
          Faces by Edges – Split faces along selected edges.
        - `VERT`
          Faces & Edges by Vertices – Split faces and edges connected to selected vertices.

bpy.ops.mesh.edgering_select(*\**, *extend=False*, *deselect=False*, *toggle=False*, *ring=True*)
:   Select an edge ring

    Parameters:
    :   - **extend** (*boolean**,* *(**optional**)*) – Extend, Extend the selection
        - **deselect** (*boolean**,* *(**optional**)*) – Deselect, Remove from the selection
        - **toggle** (*boolean**,* *(**optional**)*) – Toggle Select, Toggle the selection
        - **ring** (*boolean**,* *(**optional**)*) – Select Ring, Select ring

bpy.ops.mesh.edges_select_sharp(*\**, *sharpness=0.523599*)
:   Select all sharp enough edges

    Parameters:
    :   **sharpness** (*float in* *[**0.000174533**,* *3.14159**]**,* *(**optional**)*) – Sharpness

bpy.ops.mesh.extrude_context(*\**, *use_normal_flip=False*, *use_dissolve_ortho_edges=False*, *mirror=False*)
:   Extrude selection

    Parameters:
    :   - **use_normal_flip** (*boolean**,* *(**optional**)*) – Flip Normals
        - **use_dissolve_ortho_edges** (*boolean**,* *(**optional**)*) – Dissolve Orthogonal Edges
        - **mirror** (*boolean**,* *(**optional**)*) – Mirror Editing

bpy.ops.mesh.extrude_context_move(*\**, *MESH_OT_extrude_context=None*, *TRANSFORM_OT_translate=None*)
:   Extrude region together along the average normal

    Parameters:
    :   - **MESH_OT_extrude_context** (`MESH_OT_extrude_context`, (optional)) – Extrude Context, Extrude selection
        - **TRANSFORM_OT_translate** (`TRANSFORM_OT_translate`, (optional)) – Move, Move selected items

bpy.ops.mesh.extrude_edges_indiv(*\**, *use_normal_flip=False*, *mirror=False*)
:   Extrude individual edges only

    Parameters:
    :   - **use_normal_flip** (*boolean**,* *(**optional**)*) – Flip Normals
        - **mirror** (*boolean**,* *(**optional**)*) – Mirror Editing

bpy.ops.mesh.extrude_edges_move(*\**, *MESH_OT_extrude_edges_indiv=None*, *TRANSFORM_OT_translate=None*)
:   Extrude edges and move result

    Parameters:
    :   - **MESH_OT_extrude_edges_indiv** (`MESH_OT_extrude_edges_indiv`, (optional)) – Extrude Only Edges, Extrude individual edges only
        - **TRANSFORM_OT_translate** (`TRANSFORM_OT_translate`, (optional)) – Move, Move selected items

bpy.ops.mesh.extrude_faces_indiv(*\**, *mirror=False*)
:   Extrude individual faces only

    Parameters:
    :   **mirror** (*boolean**,* *(**optional**)*) – Mirror Editing

bpy.ops.mesh.extrude_faces_move(*\**, *MESH_OT_extrude_faces_indiv=None*, *TRANSFORM_OT_shrink_fatten=None*)
:   Extrude each individual face separately along local normals

    Parameters:
    :   - **MESH_OT_extrude_faces_indiv** (`MESH_OT_extrude_faces_indiv`, (optional)) – Extrude Individual Faces, Extrude individual faces only
        - **TRANSFORM_OT_shrink_fatten** (`TRANSFORM_OT_shrink_fatten`, (optional)) – Shrink/Fatten, Shrink/fatten selected vertices along normals

bpy.ops.mesh.extrude_manifold(*\**, *MESH_OT_extrude_region=None*, *TRANSFORM_OT_translate=None*)
:   Extrude, dissolves edges whose faces form a flat surface and intersect new edges

    Parameters:
    :   - **MESH_OT_extrude_region** (`MESH_OT_extrude_region`, (optional)) – Extrude Region, Extrude region of faces
        - **TRANSFORM_OT_translate** (`TRANSFORM_OT_translate`, (optional)) – Move, Move selected items

bpy.ops.mesh.extrude_region(*\**, *use_normal_flip=False*, *use_dissolve_ortho_edges=False*, *mirror=False*)
:   Extrude region of faces

    Parameters:
    :   - **use_normal_flip** (*boolean**,* *(**optional**)*) – Flip Normals
        - **use_dissolve_ortho_edges** (*boolean**,* *(**optional**)*) – Dissolve Orthogonal Edges
        - **mirror** (*boolean**,* *(**optional**)*) – Mirror Editing

bpy.ops.mesh.extrude_region_move(*\**, *MESH_OT_extrude_region=None*, *TRANSFORM_OT_translate=None*)
:   Extrude region and move result

    Parameters:
    :   - **MESH_OT_extrude_region** (`MESH_OT_extrude_region`, (optional)) – Extrude Region, Extrude region of faces
        - **TRANSFORM_OT_translate** (`TRANSFORM_OT_translate`, (optional)) – Move, Move selected items

bpy.ops.mesh.extrude_region_shrink_fatten(*\**, *MESH_OT_extrude_region=None*, *TRANSFORM_OT_shrink_fatten=None*)
:   Extrude region together along local normals

    Parameters:
    :   - **MESH_OT_extrude_region** (`MESH_OT_extrude_region`, (optional)) – Extrude Region, Extrude region of faces
        - **TRANSFORM_OT_shrink_fatten** (`TRANSFORM_OT_shrink_fatten`, (optional)) – Shrink/Fatten, Shrink/fatten selected vertices along normals

bpy.ops.mesh.extrude_repeat(*\**, *steps=10*, *offset=(0.0, 0.0, 0.0)*, *scale_offset=1.0*)
:   Extrude selected vertices, edges or faces repeatedly

    Parameters:
    :   - **steps** (*int in* *[**0**,* *1000000**]**,* *(**optional**)*) – Steps
        - **offset** ([`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 3 items in [-100000, 100000], (optional)) – Offset, Offset vector
        - **scale_offset** (*float in* *[**0**,* *inf**]**,* *(**optional**)*) – Scale Offset

bpy.ops.mesh.extrude_vertices_move(*\**, *MESH_OT_extrude_verts_indiv=None*, *TRANSFORM_OT_translate=None*)
:   Extrude vertices and move result

    Parameters:
    :   - **MESH_OT_extrude_verts_indiv** (`MESH_OT_extrude_verts_indiv`, (optional)) – Extrude Only Vertices, Extrude individual vertices only
        - **TRANSFORM_OT_translate** (`TRANSFORM_OT_translate`, (optional)) – Move, Move selected items

bpy.ops.mesh.extrude_verts_indiv(*\**, *mirror=False*)
:   Extrude individual vertices only

    Parameters:
    :   **mirror** (*boolean**,* *(**optional**)*) – Mirror Editing

bpy.ops.mesh.face_make_planar(*\**, *factor=1.0*, *repeat=1*)
:   Flatten selected faces

    Parameters:
    :   - **factor** (*float in* *[**-10**,* *10**]**,* *(**optional**)*) – Factor
        - **repeat** (*int in* *[**1**,* *10000**]**,* *(**optional**)*) – Iterations

bpy.ops.mesh.face_split_by_edges()
:   Weld loose edges into faces (splitting them into new faces)

bpy.ops.mesh.faces_select_linked_flat(*\**, *sharpness=0.0174533*)
:   Select linked faces by angle

    Parameters:
    :   **sharpness** (*float in* *[**0.000174533**,* *3.14159**]**,* *(**optional**)*) – Sharpness

bpy.ops.mesh.faces_shade_flat()
:   Display faces flat

bpy.ops.mesh.faces_shade_smooth()
:   Display faces smooth (using vertex normals)

bpy.ops.mesh.fill(*\**, *use_beauty=True*)
:   Fill a selected edge loop with faces

    Parameters:
    :   **use_beauty** (*boolean**,* *(**optional**)*) – Beauty, Use best triangulation division

bpy.ops.mesh.fill_grid(*\**, *span=1*, *offset=0*, *use_interp_simple=False*)
:   Fill grid from two loops

    Parameters:
    :   - **span** (*int in* *[**1**,* *1000**]**,* *(**optional**)*) – Span, Number of grid columns
        - **offset** (*int in* *[**-1000**,* *1000**]**,* *(**optional**)*) – Offset, Vertex that is the corner of the grid
        - **use_interp_simple** (*boolean**,* *(**optional**)*) – Simple Blending, Use simple interpolation of grid vertices

bpy.ops.mesh.fill_holes(*\**, *sides=4*)
:   Fill in holes (boundary edge loops)

    Parameters:
    :   **sides** (*int in* *[**0**,* *1000**]**,* *(**optional**)*) – Sides, Number of sides in hole required to fill (zero fills all holes)

bpy.ops.mesh.flip_normals(*\**, *only_clnors=False*)
:   Flip the direction of selected faces’ normals (and of their vertices)

    Parameters:
    :   **only_clnors** (*boolean**,* *(**optional**)*) – Custom Normals Only, Only flip the custom loop normals of the selected elements

bpy.ops.mesh.flip_quad_tessellation()
:   Flips the tessellation of selected quads

bpy.ops.mesh.hide(*\**, *unselected=False*)
:   Hide (un)selected vertices, edges or faces

    Parameters:
    :   **unselected** (*boolean**,* *(**optional**)*) – Unselected, Hide unselected rather than selected

bpy.ops.mesh.inset(*\**, *use_boundary=True*, *use_even_offset=True*, *use_relative_offset=False*, *use_edge_rail=False*, *thickness=0.0*, *depth=0.0*, *use_outset=False*, *use_select_inset=False*, *use_individual=False*, *use_interpolate=True*, *release_confirm=False*)
:   Inset new faces into selected faces

    Parameters:
    :   - **use_boundary** (*boolean**,* *(**optional**)*) – Boundary, Inset face boundaries
        - **use_even_offset** (*boolean**,* *(**optional**)*) – Offset Even, Scale the offset to give more even thickness
        - **use_relative_offset** (*boolean**,* *(**optional**)*) – Offset Relative, Scale the offset by surrounding geometry
        - **use_edge_rail** (*boolean**,* *(**optional**)*) – Edge Rail, Inset the region along existing edges
        - **thickness** (*float in* *[**0**,* *inf**]**,* *(**optional**)*) – Thickness
        - **depth** (*float in* *[**-inf**,* *inf**]**,* *(**optional**)*) – Depth
        - **use_outset** (*boolean**,* *(**optional**)*) – Outset, Outset rather than inset
        - **use_select_inset** (*boolean**,* *(**optional**)*) – Select Outer, Select the new inset faces
        - **use_individual** (*boolean**,* *(**optional**)*) – Individual, Individual face inset
        - **use_interpolate** (*boolean**,* *(**optional**)*) – Interpolate, Blend face data across the inset
        - **release_confirm** (*boolean**,* *(**optional**)*) – Confirm on Release

bpy.ops.mesh.intersect(*\**, *mode='SELECT_UNSELECT'*, *separate_mode='CUT'*, *threshold=1e-06*, *solver='EXACT'*)
:   Cut an intersection into faces

    Parameters:
    :   - **mode** (enum in [`'SELECT'`, `'SELECT_UNSELECT'`], (optional)) –

          Source

          - `SELECT`
            Self Intersect – Self intersect selected faces.
          - `SELECT_UNSELECT`
            Selected/Unselected – Intersect selected with unselected faces.
        - **separate_mode** (enum in [`'ALL'`, `'CUT'`, `'NONE'`], (optional)) –

          Separate Mode

          - `ALL`
            All – Separate all geometry from intersections.
          - `CUT`
            Cut – Cut into geometry keeping each side separate (Selected/Unselected only).
          - `NONE`
            Merge – Merge all geometry from the intersection.
        - **threshold** (*float in* *[**0**,* *0.01**]**,* *(**optional**)*) – Merge Threshold
        - **solver** (enum in [`'FLOAT'`, `'EXACT'`], (optional)) –

          Solver, Which Intersect solver to use

          - `FLOAT`
            Float – Simple solver with good performance, without support for overlapping geometry.
          - `EXACT`
            Exact – Slower solver with the best results for coplanar faces.

bpy.ops.mesh.intersect_boolean(*\**, *operation='DIFFERENCE'*, *use_swap=False*, *use_self=False*, *threshold=1e-06*, *solver='EXACT'*)
:   Cut solid geometry from selected to unselected

    Parameters:
    :   - **operation** (enum in [`'INTERSECT'`, `'UNION'`, `'DIFFERENCE'`], (optional)) – Boolean Operation, Which boolean operation to apply
        - **use_swap** (*boolean**,* *(**optional**)*) – Swap, Use with difference intersection to swap which side is kept
        - **use_self** (*boolean**,* *(**optional**)*) – Self Intersection, Do self-union or self-intersection
        - **threshold** (*float in* *[**0**,* *0.01**]**,* *(**optional**)*) – Merge Threshold
        - **solver** (enum in [`'FLOAT'`, `'EXACT'`], (optional)) –

          Solver, Which Boolean solver to use

          - `FLOAT`
            Float – Faster solver, some limitations.
          - `EXACT`
            Exact – Exact solver, slower, handles more cases.

bpy.ops.mesh.knife_project(*\**, *cut_through=False*)
:   Use other objects outlines and boundaries to project knife cuts

    Parameters:
    :   **cut_through** (*boolean**,* *(**optional**)*) – Cut Through, Cut through all faces, not just visible ones

bpy.ops.mesh.knife_tool(*\**, *use_occlude_geometry=True*, *only_selected=False*, *xray=True*, *visible_measurements='NONE'*, *angle_snapping='NONE'*, *angle_snapping_increment=0.523599*, *wait_for_input=True*)
:   Cut new topology

    Parameters:
    :   - **use_occlude_geometry** (*boolean**,* *(**optional**)*) – Occlude Geometry, Only cut the front most geometry
        - **only_selected** (*boolean**,* *(**optional**)*) – Only Selected, Only cut selected geometry
        - **xray** (*boolean**,* *(**optional**)*) – X-Ray, Show cuts hidden by geometry
        - **visible_measurements** (enum in [`'NONE'`, `'BOTH'`, `'DISTANCE'`, `'ANGLE'`], (optional)) –

          Measurements, Visible distance and angle measurements

          - `NONE`
            None – Show no measurements.
          - `BOTH`
            Both – Show both distances and angles.
          - `DISTANCE`
            Distance – Show just distance measurements.
          - `ANGLE`
            Angle – Show just angle measurements.
        - **angle_snapping** (enum in [`'NONE'`, `'SCREEN'`, `'RELATIVE'`], (optional)) –

          Angle Snapping, Angle snapping mode

          - `NONE`
            None – No angle snapping.
          - `SCREEN`
            Screen – Screen space angle snapping.
          - `RELATIVE`
            Relative – Angle snapping relative to the previous cut edge.
        - **angle_snapping_increment** (*float in* *[**0**,* *3.14159**]**,* *(**optional**)*) – Angle Snap Increment, The angle snap increment used when in constrained angle mode
        - **wait_for_input** (*boolean**,* *(**optional**)*) – Wait for Input

bpy.ops.mesh.loop_multi_select(*\**, *ring=False*)
:   Select a loop of connected edges by connection type

    Parameters:
    :   **ring** (*boolean**,* *(**optional**)*) – Ring

bpy.ops.mesh.loop_select(*\**, *extend=False*, *deselect=False*, *toggle=False*, *ring=False*)
:   Select a loop of connected edges

    Parameters:
    :   - **extend** (*boolean**,* *(**optional**)*) – Extend Select, Extend the selection
        - **deselect** (*boolean**,* *(**optional**)*) – Deselect, Remove from the selection
        - **toggle** (*boolean**,* *(**optional**)*) – Toggle Select, Toggle the selection
        - **ring** (*boolean**,* *(**optional**)*) – Select Ring, Select ring

bpy.ops.mesh.loop_to_region(*\**, *select_bigger=False*)
:   Select region of faces inside of a selected loop of edges

    Parameters:
    :   **select_bigger** (*boolean**,* *(**optional**)*) – Select Bigger, Select bigger regions instead of smaller ones

bpy.ops.mesh.loopcut(*\**, *number_cuts=1*, *smoothness=0.0*, *falloff='INVERSE_SQUARE'*, *object_index=-1*, *edge_index=-1*, *mesh_select_mode_init=(False, False, False)*)
:   Add a new loop between existing loops

    Parameters:
    :   - **number_cuts** (*int in* *[**1**,* *1000000**]**,* *(**optional**)*) – Number of Cuts
        - **smoothness** (*float in* *[**-1000**,* *1000**]**,* *(**optional**)*) – Smoothness, Smoothness factor
        - **falloff** (enum in [Proportional Falloff Curve Only Items](bpy_types_enum_items/proportional_falloff_curve_only_items.html#rna-enum-proportional-falloff-curve-only-items), (optional)) – Falloff, Falloff type of the feather
        - **object_index** (*int in* *[**-1**,* *inf**]**,* *(**optional**)*) – Object Index
        - **edge_index** (*int in* *[**-1**,* *inf**]**,* *(**optional**)*) – Edge Index

bpy.ops.mesh.loopcut_slide(*\**, *MESH_OT_loopcut=None*, *TRANSFORM_OT_edge_slide=None*)
:   Cut mesh loop and slide it

    Parameters:
    :   - **MESH_OT_loopcut** (`MESH_OT_loopcut`, (optional)) – Loop Cut, Add a new loop between existing loops
        - **TRANSFORM_OT_edge_slide** (`TRANSFORM_OT_edge_slide`, (optional)) – Edge Slide, Slide an edge loop along a mesh

bpy.ops.mesh.mark_freestyle_edge(*\**, *clear=False*)
:   (Un)mark selected edges as Freestyle feature edges

    Parameters:
    :   **clear** (*boolean**,* *(**optional**)*) – Clear

bpy.ops.mesh.mark_freestyle_face(*\**, *clear=False*)
:   (Un)mark selected faces for exclusion from Freestyle feature edge detection

    Parameters:
    :   **clear** (*boolean**,* *(**optional**)*) – Clear

bpy.ops.mesh.mark_seam(*\**, *clear=False*)
:   (Un)mark selected edges as a seam

    Parameters:
    :   **clear** (*boolean**,* *(**optional**)*) – Clear

bpy.ops.mesh.mark_sharp(*\**, *clear=False*, *use_verts=False*)
:   (Un)mark selected edges as sharp

    Parameters:
    :   - **clear** (*boolean**,* *(**optional**)*) – Clear
        - **use_verts** (*boolean**,* *(**optional**)*) – Vertices, Consider vertices instead of edges to select which edges to (un)tag as sharp

bpy.ops.mesh.merge(*\**, *type='CENTER'*, *uvs=False*)
:   Merge selected vertices

    Parameters:
    :   - **type** (enum in [`'CENTER'`, `'CURSOR'`, `'COLLAPSE'`, `'FIRST'`, `'LAST'`], (optional)) – Type, Merge method to use
        - **uvs** (*boolean**,* *(**optional**)*) – UVs, Move UVs according to merge

bpy.ops.mesh.merge_normals()
:   Merge custom normals of selected ver