Enum FeatureDefinition 

pub enum FeatureDefinition {
    TreeNode {
        role: FeatureTreeNodeRole,
        children: Vec<FeatureId>,
        active_child: Option<FeatureId>,
    },
    BaseFeature {
        bodies: BodySelection,
    },
    InsertBodies {
        bodies: BodySelection,
    },
    Form {
        cages: Vec<SubdId>,
    },
    CosmeticThread {
        face: FaceSelection,
        diameter: Option<Length>,
        extent: Option<CosmeticThreadExtent>,
    },
    DatumPrincipalPlane {
        plane: PrincipalPlane,
    },
    DatumPlane {
        origin: Point3,
        normal: Vector3,
        u_axis: Vector3,
    },
    DatumPlaneUnresolved,
    DatumOffsetPlane {
        reference: Option<FeatureId>,
        distance: Length,
    },
    DatumAxis {
        origin: Point3,
        direction: Vector3,
    },
    DatumPoint {
        position: Point3,
    },
    DatumPointUnresolved,
    PointGeometry {
        position: Point3,
    },
    LineSegment {
        start: Point3,
        end: Point3,
    },
    CircularArc {
        center: Point3,
        normal: Vector3,
        radius: Length,
        start_angle: Angle,
        end_angle: Angle,
    },
    EllipticArc {
        center: Point3,
        normal: Vector3,
        major_axis: Vector3,
        major_radius: Length,
        minor_radius: Length,
        start_angle: Angle,
        end_angle: Angle,
    },
    Polyline {
        points: Vec<Point3>,
        closed: bool,
    },
    RegularPolygonCurve {
        sides: u32,
        circumradius: Length,
    },
    PlanarPatch {
        length: Length,
        width: Length,
    },
    FaceFromShapes {
        sources: BodySelection,
        face_maker_class: String,
    },
    DatumCoordinateSystem {
        origin: Point3,
        x_axis: Vector3,
        y_axis: Vector3,
        z_axis: Vector3,
    },
    DatumCoordinateSystemUnresolved,
    Block {
        dimensions: Option<[Length; 3]>,
        placement: Option<Transform>,
    },
    EquationCurve {
        parameter: String,
        x_expression: String,
        y_expression: String,
        z_expression: String,
        start: f64,
        end: f64,
    },
    ProjectedCurve {
        source: PathRef,
        target_faces: FaceSelection,
        direction: CurveProjectionDirection,
        bidirectional: Option<bool>,
    },
    ProjectOnSurface {
        sources: PathRef,
        support_face: FaceSelection,
        direction: Vector3,
        mode: SurfaceProjectionMode,
        height: Length,
        offset: Length,
    },
    CompositeCurve {
        segments: Vec<PathRef>,
        closed: bool,
    },
    Helix {
        axis_origin: Point3,
        axis_direction: Vector3,
        radius: Length,
        pitch: Length,
        revolutions: f64,
        start_angle: Angle,
        clockwise: bool,
        radial_growth: Option<Length>,
        cone_angle: Option<Angle>,
        segment_turns: Option<f64>,
        construction_style: Option<HelixConstructionStyle>,
    },
    HelixNativeAxis {
        axis_native_ref: String,
        axial_rise: Length,
        pitch: Length,
        revolutions: f64,
        start_angle: Angle,
        clockwise: bool,
    },
    Coil {
        construction: CoilConstruction,
        result: CoilResult,
    },
    Sphere {
        center: Point3,
        radius: Length,
        op: BooleanOp,
    },
    Torus {
        center: Point3,
        axis: Vector3,
        major_radius: Length,
        minor_radius: Length,
        op: BooleanOp,
    },
    Wrap {
        profile: ProfileRef,
        face: FaceSelection,
        mode: WrapMode,
        depth: Option<Length>,
    },
    Sketch {
        space: SketchSpace,
        sketch: Option<SketchId>,
    },
    SpatialSketch {
        sketch: Option<SpatialSketchId>,
    },
    SketchBlockDefinition {
        sketch: Option<SketchId>,
    },
    SketchBlockInstance {
        block: Option<FeatureId>,
        placement: Option<Transform>,
    },
    StoredGeometry,
    ExtractBody {
        source: BodySelection,
    },
    DerivedGeometry {
        source: FeatureId,
    },
    ImportedGeometry {
        path: String,
        format: GeometryImportFormat,
    },
    Primitive {
        solid: PrimitiveSolid,
        op: BooleanOp,
    },
    Extrude {
        profile: ProfileRef,
        direction: ExtrudeDirection,
        start: ExtrudeStart,
        extent: ExtrudeExtent,
        op: BooleanOp,
        direction_source: Option<ExtrusionDirectionSource>,
        solid: Option<bool>,
        face_maker: Option<ExtrusionFaceMaker>,
        inner_wire_taper: Option<InnerWireTaper>,
        length_along_profile_normal: Option<bool>,
        allow_multi_profile_faces: Option<bool>,
    },
    Revolve {
        construction: RevolutionConstruction,
        op: BooleanOp,
    },
    Sweep {
        profile: Option<ProfileRef>,
        sections: Vec<ProfileRef>,
        path: Option<PathRef>,
        mode: SweepMode,
        orientation: Option<SweepOrientation>,
        transition: Option<SweepTransition>,
        transformation: Option<SweepTransformation>,
        path_tangent: bool,
        linearize: bool,
        twist: Option<Angle>,
        scale: Option<f64>,
        allow_multi_profile_faces: Option<bool>,
    },
    HelicalSweep {
        construction: HelicalSweepConstruction,
        op: BooleanOp,
    },
    Binder {
        sources: Vec<BinderSource>,
        construction: BinderConstruction,
    },
    LoftUnresolved,
    FreeformSurfaceUnresolved,
    Loft {
        sections: Vec<LoftSection>,
        guides: Vec<PathRef>,
        centerline: Option<PathRef>,
        op: BooleanOp,
        closed: bool,
        solid: bool,
        ruled: bool,
        max_degree: Option<u32>,
        check_compatibility: Option<bool>,
        allow_multi_profile_faces: Option<bool>,
    },
    Rib {
        construction: RibConstruction,
        op: BooleanOp,
    },
    SheetMetalBaseFlange {
        profile: ProfileRef,
        thickness: Length,
        side: SheetMetalThicknessSide,
    },
    Fillet {
        groups: Vec<FilletGroup>,
    },
    FaceBlend {
        first_faces: FaceSelection,
        second_faces: FaceSelection,
        radius: RadiusSpec,
    },
    Chamfer {
        groups: Vec<ChamferGroup>,
        flip_direction: bool,
    },
    Shell {
        removed_faces: FaceSelection,
        thickness: Option<Length>,
        outward: Option<bool>,
        mode: Option<ShellMode>,
        join: Option<ShellJoin>,
        resolve_intersections: Option<bool>,
        allow_self_intersections: Option<bool>,
    },
    OffsetShape {
        source: BodySelection,
        distance: Length,
        mode: ShellMode,
        join: ShellJoin,
        resolve_intersections: bool,
        allow_self_intersections: bool,
        fill: bool,
        planar: bool,
    },
    Compound {
        members: BodySelection,
    },
    RefineShape {
        source: BodySelection,
    },
    ReverseShape {
        source: BodySelection,
    },
    RuledBetweenCurves {
        first: PathRef,
        second: PathRef,
        orientation: RuledCurveOrientation,
    },
    SectionShape {
        first: BodySelection,
        second: BodySelection,
        approximate: bool,
    },
    MirrorShape {
        source: BodySelection,
        plane_origin: Point3,
        plane_normal: Vector3,
        plane_reference: Option<FaceSelection>,
    },
    Thicken {
        faces: FaceSelection,
        thickness: Option<Length>,
        side: Option<ThickenSide>,
    },
    OffsetSurface {
        faces: FaceSelection,
        distance: Option<Length>,
    },
    KnitSurface {
        faces: FaceSelection,
        merge_entities: Option<bool>,
        create_solid: Option<bool>,
        gap_tolerance: Option<Length>,
    },
    SewBodies {
        bodies: BodySelection,
        gap_tolerance: Option<Length>,
    },
    FilledSurface {
        boundary: SurfaceBoundary,
        support_faces: FaceSelection,
        continuity: Option<SurfaceContinuity>,
        merge_result: Option<bool>,
    },
    BoundarySurfaceUnresolved,
    TrimSurface {
        faces: FaceSelection,
        tool: PathRef,
        keep: TrimRegion,
    },
    ExtendSurface {
        faces: FaceSelection,
        distance: Option<Length>,
        method: SurfaceExtension,
    },
    RuledSurface {
        edges: EdgeSelection,
        support_faces: FaceSelection,
        mode: RuledSurfaceMode,
    },
    Draft {
        faces: FaceSelection,
        neutral_plane: FaceSelection,
        pull_direction: Option<Vector3>,
        angle: Option<Angle>,
        outward: Option<bool>,
    },
    DraftUnresolved,
    Combine {
        target: BodySelection,
        tools: BodySelection,
        op: BooleanOp,
    },
    BoundaryFill {
        tools: BodySelection,
        cells: Vec<BodySelection>,
    },
    CutWithSurface {
        targets: BodySelection,
        tools: FaceSelection,
        reverse: bool,
    },
    TrimBodies {
        targets: BodySelection,
        tools: BodySelection,
        keep: BodyTrimSide,
    },
    SplitBody {
        targets: BodySelection,
        tools: FaceSelection,
    },
    DeleteBody {
        bodies: BodySelection,
        mode: BodyRetentionMode,
    },
    DeleteFace {
        faces: FaceSelection,
        heal: bool,
    },
    ReplaceFace {
        targets: FaceSelection,
        replacements: FaceSelection,
    },
    MoveFace {
        faces: FaceSelection,
        motion: FaceMotion,
    },
    MoveBody {
        bodies: BodySelection,
        translation: Vector3,
        rotation: Option<AxisAngle>,
        copies: u32,
    },
    Dome {
        faces: FaceSelection,
        height: Option<Length>,
        elliptical: Option<bool>,
        reverse: Option<bool>,
    },
    Flex {
        axis: Option<Vector3>,
        mode: FlexMode,
    },
    Scale {
        bodies: BodySelection,
        center: Option<ScaleCenter>,
        factors: ScaleFactors,
    },
    Hole {

        profile: Option<ProfileRef>,
        profile_filter: Option<HoleProfileFilter>,
        face: Option<FaceSelection>,
        position: Option<Point3>,
        direction: Option<Vector3>,
        placements: Vec<HolePlacement>,
        kind: HoleKind,
        exit_kind: Option<HoleKind>,
        diameter: Option<Length>,
        extent: Option<Termination>,
        bottom: Option<HoleBottom>,
        taper_angle: Option<Angle>,
        specification: Option<Box<HoleSpecification>>,
        allow_multi_profile_faces: Option<bool>,
    
},
    Pattern {
        seeds: Vec<PatternSeed>,
        pattern: PatternKind,
    },
    PostProcess {
        operation: Box<FeatureDefinition>,
        refine: bool,
        fuzzy_tolerance: FuzzyTolerance,
    },
    Native {
        kind: String,
        parameters: BTreeMap<String, String>,
        properties: BTreeMap<String, String>,
    },
}

Neutral construction semantics, with an explicit native escape hatch.

Variants

TreeNode

Non-modeling node retained in the ordered feature tree.

Fields

role: FeatureTreeNodeRole

Structural or presentation role of the node.

children: Vec<FeatureId>

Ordered features owned by this node.

active_child: Option<FeatureId>

Active child, when the source design identifies one.

BaseFeature

Direct-modeling session represented by its captured result bodies.

Fields

bodies: BodySelection

Bodies copied into the parametric timeline when the session closed.

InsertBodies

Independent bodies introduced by a copy-and-paste operation.

Fields

bodies: BodySelection

Newly created body copies in source order.

Form

Freeform modeling session represented by its final subdivision cages.

Fields

cages: Vec<SubdId>

Ordered control cages committed by the session.

CosmeticThread

Non-geometric thread annotation attached to a cylindrical face.

Fields

face: FaceSelection

Cylindrical face carrying the annotation.

diameter: Option<Length>

Nominal thread diameter, when resolved.

extent: Option<CosmeticThreadExtent>

Axial extent of the annotation, when resolved.

DatumPrincipalPlane

Built-in world-origin reference plane.

Fields

plane: PrincipalPlane

Canonical principal-plane role.

DatumPlane

Constructed reference plane.

Fields

origin: Point3

Plane origin in model space.

normal: Vector3

Plane normal.

u_axis: Vector3

In-plane u-axis.

DatumPlaneUnresolved

Constructed reference-plane family whose model-space frame is unresolved.

DatumOffsetPlane

Reference plane offset from another datum plane.

Fields

reference: Option<FeatureId>

Source plane, when its feature reference is available.

distance: Length

Signed normal offset from the source plane.

DatumAxis

Constructed reference axis.

Fields

origin: Point3

Point on the axis in model space.

direction: Vector3

Axis direction.

DatumPoint

Constructed reference point.

Fields

position: Point3

Point position in model space.

DatumPointUnresolved

Datum point whose model-space position is unresolved.

PointGeometry

Standalone model vertex constructed at one point.

Fields

position: Point3

Vertex position in the feature’s local construction frame.

LineSegment

Straight edge between two finite points.

Fields

start: Point3

Start point.

end: Point3

End point.

CircularArc

Circular edge over an angular interval.

Fields

center: Point3

Circle center in the feature’s local construction frame.

normal: Vector3

Circle-plane normal.

radius: Length

Circle radius.

start_angle: Angle

Start parameter angle.

end_angle: Angle

End parameter angle.

EllipticArc

Elliptic edge over an angular interval.

Fields

center: Point3

Ellipse center in the feature’s local construction frame.

normal: Vector3

Circle-plane normal.

major_axis: Vector3

Major-axis direction in the ellipse plane.

major_radius: Length

Major semiaxis radius.

minor_radius: Length

Minor semiaxis radius.

start_angle: Angle

Start parameter angle.

end_angle: Angle

End parameter angle.

Polyline

Ordered straight-edge chain.

Fields

points: Vec<Point3>

Ordered vertices in the feature’s local construction frame.

closed: bool

Whether the last point connects back to the first.

RegularPolygonCurve

Regular planar polygon centered at the local origin.

Fields

sides: u32

Number of polygon sides.

circumradius: Length

Center-to-vertex distance.

PlanarPatch

Rectangular bounded planar face in the local XY plane.

Fields

length: Length

Length along the local x-axis.

width: Length

Width along the local y-axis.

FaceFromShapes

Faces built from an ordered set of source shapes.

Fields

sources: BodySelection

Complete ordered source-shape selection.

face_maker_class: String

Extensible native face-building algorithm identifier.

DatumCoordinateSystem

Constructed model-space coordinate system.

Fields

origin: Point3

Frame origin.

x_axis: Vector3

Unit x-axis.

y_axis: Vector3

Unit y-axis.

z_axis: Vector3

Unit z-axis.

DatumCoordinateSystemUnresolved

Coordinate system whose model-space frame is unresolved.

Block

Rectangular solid primitive.

Fields

dimensions: Option<[Length; 3]>

Ordered local x, y, and z dimensions, when resolved.

placement: Option<Transform>

Local-to-model placement, when resolved.

EquationCurve

Parametric model-space curve defined by coordinate expressions.

Fields

parameter: String

Independent parameter symbol used by the coordinate expressions.

x_expression: String

Model-space x-coordinate expression.

y_expression: String

Model-space y-coordinate expression.

z_expression: String

Model-space z-coordinate expression.

start: f64

Inclusive lower parameter bound.

end: f64

Inclusive upper parameter bound.

ProjectedCurve

Curve produced by projecting a source path onto target faces.

Fields

source: PathRef

Sketch or model-space path being projected.

target_faces: FaceSelection

Faces receiving the projected curve.

direction: CurveProjectionDirection

Direction law used by the projection.

bidirectional: Option<bool>

Whether projection proceeds in both directions, when resolved.

ProjectOnSurface

Shapes projected along a direction onto one support surface.

Fields

sources: PathRef

Ordered shapes and subelements projected onto the support.

support_face: FaceSelection

Single support face receiving the projection.

direction: Vector3

Unit projection direction.

mode: SurfaceProjectionMode

Result topology retained from the projected shapes.

height: Length

Normal extrusion height used to turn projected faces into solids.

offset: Length

Normal offset applied to the projected result.

CompositeCurve

Ordered chain of source paths exposed as one construction curve.

Fields

segments: Vec<PathRef>

Source segments in traversal order.

closed: bool

Whether the final segment joins the first.

Helix

Circular helix or planar spiral constructed around an axis.

Fields

axis_origin: Point3

Point on the construction axis at the curve start.

axis_direction: Vector3

Construction-axis direction.

radius: Length

Initial radial distance from the axis.

pitch: Length

Signed axial rise per revolution; zero produces a planar spiral.

revolutions: f64

Positive number of revolutions.

start_angle: Angle

Angular position at the curve start.

clockwise: bool

Whether angular travel is clockwise when viewed along the axis.

radial_growth: Option<Length>

Radial growth per revolution for a planar spiral, when non-cylindrical.

cone_angle: Option<Angle>

Cone half-angle for a conical helix, when non-cylindrical.

segment_turns: Option<f64>

Number of turns per generated curve subdivision, when requested.

construction_style: Option<HelixConstructionStyle>

Persisted construction algorithm generation, when selectable.

HelixNativeAxis

Circular helix with retained native axis placement.

Fields

axis_native_ref: String

Source-native record carrying the unresolved construction axis.

axial_rise: Length

Signed total rise along the axis.

pitch: Length

Signed axial rise per revolution.

revolutions: f64

Positive number of revolutions.

start_angle: Angle

Angular position at the curve start.

clockwise: bool

Whether angular travel is clockwise when viewed along the axis.

Coil

Solid primitive formed by sweeping a generated section along a helix or spiral.

Fields

construction: CoilConstruction

Complete geometric and parametric construction definition.

result: CoilResult

Result-body semantics.

Sphere

Solid sphere primitive.

Fields

center: Point3

Sphere center in model space.

radius: Length

Positive sphere radius.

op: BooleanOp

Boolean combination with existing bodies.

Torus

Solid torus primitive.

Fields

center: Point3

Torus center in model space.

axis: Vector3

Unit normal of the torus center plane.

major_radius: Length

Positive distance from the center to the tube centerline.

minor_radius: Length

Positive tube radius.

op: BooleanOp

Boolean combination with existing bodies.

Wrap

Profile mapped onto a target face.

Fields

profile: ProfileRef

Sketch or face profile mapped onto the target.

face: FaceSelection

Face receiving the mapped profile.

mode: WrapMode

Material or imprint operation performed by the mapping.

depth: Option<Length>

Normal offset for emboss and deboss operations.

Sketch

Solved sketch node in the construction history.

Fields

space: SketchSpace

Coordinate space containing the sketch geometry.

sketch: Option<SketchId>

Neutral planar sketch geometry owned by this history node, when resolved. Neutral sketch geometry owned by this history node, when resolved.

SpatialSketch

Solved spatial-sketch node in the construction history.

Fields

sketch: Option<SpatialSketchId>

Neutral model-space sketch geometry owned by this history node, when resolved.

SketchBlockDefinition

Reusable planar sketch geometry.

Fields

sketch: Option<SketchId>

Neutral sketch geometry owned by the block, when resolved.

SketchBlockInstance

Placement of one reusable sketch-block definition.

Fields

block: Option<FeatureId>

Referenced block definition, when resolved.

placement: Option<Transform>

Affine placement in the owning sketch space, when resolved.

StoredGeometry

Directly stored geometry with no replayable parametric construction.

The feature’s outputs identify the retained bodies when geometry is present.

ExtractBody

Body geometry copied from existing bodies.

Fields

source: BodySelection

Bodies supplying the copied geometry.

DerivedGeometry

Geometry copied from an earlier feature without an additional modeling operation.

Fields

source: FeatureId

Feature supplying the copied geometry.

ImportedGeometry

Geometry imported from an external model file.

Fields

path: String

External source path exactly as persisted by the design.

format: GeometryImportFormat

Model format read from the external file.

Primitive

Parametric analytic solid primitive.

Fields

solid: PrimitiveSolid

Primitive dimensions and angular bounds.

op: BooleanOp

Boolean combination with an existing PartDesign body.

Extrude

Linear extrusion of a profile.

Fields

profile: ProfileRef

Profile swept along direction.

direction: ExtrudeDirection

Direction in which the profile is swept.

start: ExtrudeStart

Plane or face from which the extrusion begins.

extent: ExtrudeExtent

How far the extrusion travels on each of its sides.

op: BooleanOp

Boolean combination with existing bodies.

direction_source: Option<ExtrusionDirectionSource>

Persisted source used to resolve the extrusion direction.

solid: Option<bool>

Whether the result is a solid (true) or sheet (false), when selectable.

face_maker: Option<ExtrusionFaceMaker>

Native face-building policy used to turn closed wires into faces.

inner_wire_taper: Option<InnerWireTaper>

Taper orientation used for inner wires, when selectable.

length_along_profile_normal: Option<bool>

Whether stored lengths are measured along the profile normal instead of the sweep axis.

allow_multi_profile_faces: Option<bool>

Whether a profile containing multiple faces is accepted as one operation.

Revolve

Revolution of a profile around an axis.

Fields

construction: RevolutionConstruction

Independently resolved construction inputs.

op: BooleanOp

Boolean combination with existing bodies.

Sweep

Sweep of a profile along a path.

Fields

profile: Option<ProfileRef>

Cross-section swept along the path, when resolved.

sections: Vec<ProfileRef>

Additional cross-sections after the primary profile, in path order.

path: Option<PathRef>

Trajectory followed by the profile, when resolved.

mode: SweepMode

Result family and solid Boolean operation.

orientation: Option<SweepOrientation>

Rule used to orient cross-sections along the path.

transition: Option<SweepTransition>

Corner continuation used where path segments meet.

transformation: Option<SweepTransformation>

Interpolation law used between multiple cross-sections.

path_tangent: bool

Whether tangent-connected edges are included in the primary path.

linearize: bool

Whether linear edges and planar faces are simplified after construction.

twist: Option<Angle>

Total profile twist along the path, when specified.

scale: Option<f64>

End-to-start profile scale ratio, when specified.

allow_multi_profile_faces: Option<bool>

Whether a profile containing multiple faces is accepted as one operation.

HelicalSweep

Solid sweep of a profile along a parametrically defined helix or spiral.

Fields

construction: HelicalSweepConstruction

Complete helix path and profile construction.

op: BooleanOp

Boolean combination with the existing body.

Binder

Live or frozen reference geometry imported from other design features.

Fields

sources: Vec<BinderSource>

Ordered source objects and selected subelements.

construction: BinderConstruction

Binding and derived-shape construction semantics.

LoftUnresolved

Loft-family skin whose section semantics remain unresolved.

FreeformSurfaceUnresolved

Freeform surface whose control geometry remains unresolved.

Loft

Loft through an ordered sequence of profile or point sections.

Fields

sections: Vec<LoftSection>

Ordered cross-sections from the loft start to end.

guides: Vec<PathRef>

Optional ordered guide trajectories.

centerline: Option<PathRef>

Optional centerline to which the loft sections remain normal.

op: BooleanOp

Boolean combination with existing bodies.

closed: bool

Whether the loft closes from the last section to the first.

solid: bool

Whether the sections bound a solid instead of a sheet body.

ruled: bool

Whether adjacent sections are connected by straight ruled spans.

max_degree: Option<u32>

Maximum polynomial degree used to interpolate the sections, when constrained.

check_compatibility: Option<bool>

Whether section topology is checked and adjusted for compatibility, when carried.

allow_multi_profile_faces: Option<bool>

Whether profiles containing multiple faces are accepted as one operation.

Rib

Thin rib grown from a profile.

Fields

construction: RibConstruction

Independently resolved construction inputs.

op: BooleanOp

Boolean combination with existing bodies.

SheetMetalBaseFlange

Planar sheet-metal body created from a closed profile.

Fields

profile: ProfileRef

Closed profile defining the planar sheet boundary.

thickness: Length

Finished sheet thickness.

side: SheetMetalThicknessSide

Distribution of thickness relative to the profile plane.

Fillet

Edge fillet.

Fields

groups: Vec<FilletGroup>

Ordered edge groups and their radius laws.

FaceBlend

Blend constructed between two face sets.

Fields

first_faces: FaceSelection

First support-face set.

second_faces: FaceSelection

Second support-face set.

radius: RadiusSpec

Radius law along the face intersection.

Chamfer

Edge chamfer.

Fields

groups: Vec<ChamferGroup>

Ordered edge groups and their dimensional specifications.

flip_direction: bool

Whether the dimensional reference side is reversed.

Shell

Thin-wall shell operation.

Fields

removed_faces: FaceSelection

Faces removed to open the shell.

thickness: Option<Length>

Wall thickness left after shelling, when resolved.

outward: Option<bool>

Whether the wall is grown outward from the original boundary, as opposed to inward, when resolved.

mode: Option<ShellMode>

Offset construction used to generate the wall.

join: Option<ShellJoin>

Corner continuation law used between offset faces.

resolve_intersections: Option<bool>

Whether intersecting offset regions are resolved during construction.

allow_self_intersections: Option<bool>

Whether self-intersecting offset regions may be retained.

OffsetShape

Offsets an entire source shape without removing opening faces.

Fields

source: BodySelection

Source shape or body to offset.

distance: Length

Signed normal offset in canonical millimeters.

mode: ShellMode

Offset construction mode.

join: ShellJoin

Corner continuation law.

resolve_intersections: bool

Whether intersecting regions are resolved.

allow_self_intersections: bool

Whether self-intersecting regions may be retained.

fill: bool

Whether open offset boundaries are filled.

planar: bool

Whether planar two-dimensional offset rules are used.

Compound

Builds one compound topology node from ordered source shapes.

Fields

members: BodySelection

Ordered source members retained as a native or resolved selection.

RefineShape

Removes redundant splitter topology from a source shape.

Fields

source: BodySelection

Source shape whose coincident boundaries are simplified.

ReverseShape

Reverses the topological orientation of a source shape.

Fields

source: BodySelection

Source shape whose complete orientation is reversed.

RuledBetweenCurves

Ruled sheet connecting two ordered boundary curves.

Fields

first: PathRef

First source boundary.

second: PathRef

Second source boundary.

orientation: RuledCurveOrientation

Traversal relationship between the two boundaries.

SectionShape

Intersection curves produced where two source shapes meet.

Fields

first: BodySelection

First intersected source shape.

second: BodySelection

Second intersected source shape.

approximate: bool

Whether the resulting section edges are approximated.

MirrorShape

Reflects one source shape across a model-space plane.

Fields

source: BodySelection

Shape transformed into the mirrored result.

plane_origin: Point3

Point on the persisted resolved mirror plane.

plane_normal: Vector3

Unit normal of the persisted resolved mirror plane.

plane_reference: Option<FaceSelection>

Native plane, face, or circle reference that supplied the resolved plane.

Thicken

Adds material normal to selected faces.

Fields

faces: FaceSelection

Faces offset by the operation.

thickness: Option<Length>

Finished added thickness, when resolved.

side: Option<ThickenSide>

Distribution of thickness relative to the selected faces, when resolved.

OffsetSurface

Surface copied at a signed normal offset from selected support faces.

Fields

faces: FaceSelection

Faces supplying the source surface geometry.

distance: Option<Length>

Signed normal offset in canonical millimeters.

KnitSurface

Joins selected surface bodies along coincident or near-coincident boundaries.

Fields

faces: FaceSelection

Faces participating in the knit operation.

merge_entities: Option<bool>

Whether coincident face and edge entities are merged.

create_solid: Option<bool>

Whether a closed result is converted to a solid body.

gap_tolerance: Option<Length>

Maximum boundary gap accepted by the operation.

SewBodies

Joins sheet or solid bodies along coincident boundaries.

Fields

bodies: BodySelection

Bodies participating in the sew operation.

gap_tolerance: Option<Length>

Maximum accepted boundary gap, when resolved.

FilledSurface

Surface patch spanning a selected edge boundary.

Fields

boundary: SurfaceBoundary

Closed boundary of the generated patch.

support_faces: FaceSelection

Adjacent faces supplying tangent or curvature conditions.

continuity: Option<SurfaceContinuity>

Continuity imposed against the support faces, when resolved.

merge_result: Option<bool>

Whether the generated patch is merged into adjacent surface bodies, when resolved.

BoundarySurfaceUnresolved

Boundary-surface operation whose curve networks remain unresolved.

TrimSurface

Restricts selected surface faces to one side of a trimming path.

Fields

faces: FaceSelection

Surface faces modified by the operation.

tool: PathRef

Sketch or model-space path defining the trim boundary.

keep: TrimRegion

Region retained after trimming.

ExtendSurface

Extends selected surface boundaries by a fixed distance.

Fields

faces: FaceSelection

Surface faces whose boundaries are extended.

distance: Option<Length>

Positive extension distance in canonical millimeters.

method: SurfaceExtension

Geometric continuation law.

RuledSurface

Ruled surface grown from selected boundary edges.

Fields

edges: EdgeSelection

Boundary edges from which the surface is generated.

support_faces: FaceSelection

Adjacent faces supplying normal or tangent context.

mode: RuledSurfaceMode

Direction law and extension distance.

Draft

Taper applied to selected faces about a neutral plane.

Fields

faces: FaceSelection

Faces whose angle is modified.

neutral_plane: FaceSelection

Neutral plane that remains fixed during the operation.

pull_direction: Option<Vector3>

Pull direction used to measure the draft angle.

angle: Option<Angle>

Signed draft angle.

outward: Option<bool>

Whether material is added away from the pull direction.

DraftUnresolved

Draft family whose operands remain unresolved.

Combine

Boolean operation between existing bodies.

Fields

target: BodySelection

Body modified by the operation.

tools: BodySelection

Bodies consumed as Boolean tools.

op: BooleanOp

Join, cut, or intersection operation.

BoundaryFill

Creates solid bodies from selected cells enclosed by boundary bodies.

Fields

tools: BodySelection

Bodies whose faces partition space into candidate cells.

cells: Vec<BodySelection>

Enclosed cells retained as result bodies, in source order.

CutWithSurface

Removes one side of selected bodies using selected surface faces.

Fields

targets: BodySelection

Bodies cut by the operation.

tools: FaceSelection

Oriented surface faces defining the cut.

reverse: bool

Whether the side opposite the default tool orientation is removed.

TrimBodies

Removes one side of target bodies using ordered tool bodies.

Fields

targets: BodySelection

Bodies modified by the operation.

tools: BodySelection

Bodies defining the trimming boundary.

keep: BodyTrimSide

Side retained by the trim.

SplitBody

Partitions selected bodies with selected surface faces while retaining every resulting side.

Fields

targets: BodySelection

Bodies partitioned by the operation.

tools: FaceSelection

Surface faces extended as necessary to partition the targets.

DeleteBody

Deletes bodies directly or retains only the selected bodies.

Fields

bodies: BodySelection

Bodies selected by the operation.

mode: BodyRetentionMode

Whether selected bodies are deleted or retained.

DeleteFace

Removal of selected faces from an existing body.

Fields

faces: FaceSelection

Faces removed by the operation.

heal: bool

Whether adjacent faces extend to heal the resulting boundary.

ReplaceFace

Replaces selected faces with another face set.

Fields

targets: FaceSelection

Faces removed from the target body.

replacements: FaceSelection

Faces whose underlying geometry supplies the replacement.

MoveFace

Direct motion of selected faces.

Fields

faces: FaceSelection

Faces modified by the operation.

motion: FaceMotion

Motion applied to the selected faces.

MoveBody

Rigid translation or rotation of selected bodies, optionally creating copies.

Fields

bodies: BodySelection

Bodies transformed by the operation.

translation: Vector3

Model-space translation vector in canonical millimeters.

rotation: Option<AxisAngle>

Axis-angle rotation applied with the translation.

copies: u32

Number of transformed copies; zero moves the selected bodies.

Dome

Dome grown from selected planar faces.

Fields

faces: FaceSelection

Faces that bound the dome base.

height: Option<Length>

Dome height measured normal to the base, when resolved.

elliptical: Option<bool>

Whether the profile is elliptical rather than spherical, when resolved.

reverse: Option<bool>

Whether growth opposes the selected-face normal, when resolved.

Flex

Deformation of existing geometry about a feature axis.

Fields

axis: Option<Vector3>

Flex axis direction in model space, when resolved.

mode: FlexMode

Applied deformation mode and magnitude.

Scale

Scales selected bodies about a model-space point.

Fields

bodies: BodySelection

Bodies transformed by the operation.

center: Option<ScaleCenter>

Fixed locus of the scale transform.

factors: ScaleFactors

Independently decoded uniform and axis scale factors.

Hole

Drilled or machined hole.

Fields

profile: Option<ProfileRef>

Sketch or profile supplying one or more hole locations.

profile_filter: Option<HoleProfileFilter>

Geometry families in the profile that generate hole locations.

face: Option<FaceSelection>

Face the hole is placed on, when known.

position: Option<Point3>

Shared hole entry position when the construction carries one location separately.

direction: Option<Vector3>

Shared drilling direction when carried independently of complete placements.

placements: Vec<HolePlacement>

Complete one-or-many hole placements. Empty when placement is unresolved.

kind: HoleKind

Structural drilling, entry-treatment, and threading form.

exit_kind: Option<HoleKind>

Exit treatment at the far side, when distinct from the entry treatment.

diameter: Option<Length>

Hole diameter, when resolved.

extent: Option<Termination>

How deep the hole extends, when resolved. Holes travel on one side only, so the termination law needs no sidedness wrapper.

bottom: Option<HoleBottom>

Shape and depth convention at the blind end of the hole.

taper_angle: Option<Angle>

Included taper angle for a conical hole, when enabled.

specification: Option<Box<HoleSpecification>>

Standard sizing and thread construction, when specified.

allow_multi_profile_faces: Option<bool>

Whether a profile containing multiple faces is accepted as one operation.

Pattern

Repetition or reflection of existing features.

Fields

seeds: Vec<PatternSeed>

Geometry being repeated or reflected; empty when the source selection is unresolved.

pattern: PatternKind

Spatial transform defining the repetition or reflection.

PostProcess

Operation followed by source-requested topology cleanup.

Fields

operation: Box<FeatureDefinition>

Underlying construction whose result is post-processed.

refine: bool

Whether redundant splitter boundaries are removed.

fuzzy_tolerance: FuzzyTolerance

Boolean-operation tolerance selection carried by the feature family.

Native

Source-native operation without neutral semantics.

Fields

kind: String

Native feature-type tag (e.g. "Extrude", "Fillet").

parameters: BTreeMap<String, String>

Source parametric input values keyed by parameter name.

properties: BTreeMap<String, String>

Source operation attributes that are not dimensional parameters.

Trait Implementations

impl Clone for FeatureDefinition

fn clone(&self) -> FeatureDefinition

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for FeatureDefinition

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for FeatureDefinition

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for FeatureDefinition

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for FeatureDefinition

fn eq(&self, other: &FeatureDefinition) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for FeatureDefinition

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for FeatureDefinition