dxcad-sdk 0.1.0__py3-none-any.whl

dxcad-stubs/__init__.pyi

@@ -0,0 +1,5 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2026 Designmatix Ltd
+"""DX-CAD's package, as far as the SDK types it: the model language, in dxcad.model."""
+
+__version__: str

dxcad-stubs/model.pyi

@@ -0,0 +1,644 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2026 Designmatix Ltd
+"""Every name a DX-CAD model.py starts with: dxcad.model's own functions and classes.
+
+Generated by `python -m dxcad.docsgen sdk` from DX-CAD's signatures; do not
+edit. OCCT's own names, which the namespace also hands a model, are typed by
+OCCT's stubs and are not here.
+"""
+
+from typing import Any
+
+#: An OCCT shape (TopoDS_Shape and its kinds).
+Shape = Any
+Vec2 = tuple[float, float]
+Vec3 = tuple[float, float, float]
+
+BOOLEAN_FUZZY_VALUE: float
+DEFAULT_LINETYPE: str
+EDGE_PARALLEL_TOLERANCE: float
+FULL_TURN: float
+LINETYPES: tuple
+LOOP_AREA_TOLERANCE: float
+MINIMUM_SEGMENTS: int
+OVERHANG_BED_TOLERANCE: float
+OVERHANG_SAMPLES: int
+PLANE_PARALLEL_TOLERANCE: float
+PLANE_TOLERANCE: float
+TEXT_ALIGNS: tuple
+WALL_RAY_START: float
+
+class Bend:
+    """One bend as it lies on the flat: where it starts and ends, and how it goes."""
+    lines: Any
+    angle: float
+    direction: str
+    radius: float
+    def __init__(self, lines: Any, angle: float, direction: str, radius: float) -> None: ...
+
+class BooleanError(RuntimeError):
+    """A boolean operation did not produce one valid solid."""
+
+class Coincident:
+    """Points a and b at the same place."""
+    a: str
+    b: str
+    def __init__(self, a: str, b: str) -> None: ...
+
+class Concentric:
+    """Two circles, of centres a and b, share their centre."""
+    a: str
+    b: str
+    def __init__(self, a: str, b: str) -> None: ...
+
+class Diameter:
+    """A circle of centre a through rim point b is `value` across. Radius, doubled."""
+    a: str
+    b: str
+    value: float
+    def __init__(self, a: str, b: str, value: float) -> None: ...
+
+class Distance:
+    """Points a and b `value` apart. A negative value raises ValueError."""
+    a: str
+    b: str
+    value: float
+    def __init__(self, a: str, b: str, value: float) -> None: ...
+
+class DraftError(RuntimeError):
+    """A draft did not produce one valid solid."""
+
+class Equal:
+    """Points a and b as far apart as c and d: two sides, or two circles' radii."""
+    a: str
+    b: str
+    c: str
+    d: str
+    def __init__(self, a: str, b: str, c: str, d: str) -> None: ...
+
+class FilletError(RuntimeError):
+    """A fillet or chamfer did not produce one valid solid."""
+
+class FlatPattern:
+    """A sheet part unfolded: the cut outline and the bends, on the base's plane."""
+    outline: tuple[Vec2, ...]
+    bends: tuple[Bend, ...]
+    spec: SheetSpec
+    holes: Any
+    cutouts: Any
+    leg_cutouts: tuple[tuple[Vec2, Vec2, Vec2, Vec2], ...]
+    notes: tuple[tuple[float, float, str] | tuple[float, float, str, float], ...]
+    cuts: tuple[tuple[Vec2, ...], ...]
+    openings: tuple[tuple[Vec2, ...], ...]
+    arcs: Any
+    def __init__(self, outline: tuple[Vec2, ...], bends: tuple[Bend, ...], spec: SheetSpec, holes: Any = ..., cutouts: Any = ..., leg_cutouts: tuple[tuple[Vec2, Vec2, Vec2, Vec2], ...] = ..., notes: tuple[tuple[float, float, str] | tuple[float, float, str, float], ...] = ..., cuts: tuple[tuple[Vec2, ...], ...] = ..., openings: tuple[tuple[Vec2, ...], ...] = ..., arcs: Any = ...) -> None: ...
+    def bounds(self) -> tuple[Vec2, Vec2]:
+        """The outline's lowest and highest (x, y), an arc's own reach counted (item 837)."""
+        ...
+
+class HollowError(RuntimeError):
+    """A shelling operation did not produce one valid solid."""
+
+class Horizontal:
+    """Points a and b at the same y."""
+    a: str
+    b: str
+    def __init__(self, a: str, b: str) -> None: ...
+
+class LoftError(RuntimeError):
+    """A loft did not produce one valid solid."""
+
+class Plane:
+    """A 2D coordinate system living somewhere in 3D, on top of gp_Ax3."""
+    def __init__(self, origin: Vec3, normal: Vec3, x_dir: Vec3) -> None: ...
+    @classmethod
+    def from_face(cls, face: Shape) -> Plane:
+        """The plane of a planar face, so a sketch can sit on an existing part."""
+        ...
+    def from_world(self, point: Vec3) -> Vec2:
+        """Drop a model point back into the plane's (x, y)."""
+        ...
+    def intersect_ray(self, origin: Vec3, direction: Vec3) -> PlaneHit | None:
+        """Where the ray (origin, direction) meets this plane, or None."""
+        ...
+    @property
+    def normal(self) -> Vec3: ...
+    def offset(self, distance: float) -> Plane:
+        """A new Plane `distance` along the normal, parallel to this one."""
+        ...
+    @property
+    def origin(self) -> Vec3: ...
+    def to_world(self, point: Vec2) -> Vec3:
+        """Lift an in-plane (x, y) into model space."""
+        ...
+    @property
+    def x_dir(self) -> Vec3: ...
+    @property
+    def y_dir(self) -> Vec3: ...
+
+class PlaneHit(tuple):
+    """Where a ray met a plane: the world point, its (x, y) and how far along."""
+
+class Radius:
+    """A circle of centre a through rim point b has radius `value`."""
+    a: str
+    b: str
+    value: float
+    def __init__(self, a: str, b: str, value: float) -> None: ...
+
+class SheetPart:
+    """A sheet part: its solid and the record it was built from."""
+    solid: Shape
+    spec: SheetSpec
+    profile: tuple[Vec2, ...]
+    plane: Plane
+    flanges: Any
+    holes: Any
+    flange_holes: Any
+    cutouts: Any
+    flange_cutouts: Any
+    return_holes: Any
+    return_cutouts: Any
+    corner_trims: tuple[tuple[int, tuple[Vec2, ...]], ...]
+    corner_cuts: Any
+    corner_tabs: Any
+    return_turns: Any
+    corner_treatment: str | None
+    corner_gap: float | None
+    notes: tuple[str, ...]
+    arcs: Any
+    kind: str | None
+    record: object
+    def __init__(self, solid: Shape, spec: SheetSpec, profile: tuple[Vec2, ...], plane: Plane, flanges: Any = ..., holes: Any = ..., flange_holes: Any = ..., cutouts: Any = ..., flange_cutouts: Any = ..., return_holes: Any = ..., return_cutouts: Any = ..., corner_trims: tuple[tuple[int, tuple[Vec2, ...]], ...] = ..., corner_cuts: Any = ..., corner_tabs: Any = ..., return_turns: Any = ..., corner_treatment: str | None = ..., corner_gap: float | None = ..., notes: tuple[str, ...] = ..., arcs: Any = ..., kind: str | None = ..., record: object = ...) -> None: ...
+
+class SheetSpec:
+    """The sheet a part is cut and bent from."""
+    thickness: float
+    bend_radius: float
+    k_factor: float
+    material: str
+    def __init__(self, thickness: float, bend_radius: float, k_factor: float, material: str = ...) -> None: ...
+    @classmethod
+    def from_gauge(cls, material: str, thickness: float) -> SheetSpec:
+        """The sheet a stocked gauge makes (item 608): its thickness, radius and K-factor."""
+        ...
+
+class Sketch:
+    """A profile being drawn on a plane."""
+    def __init__(self, plane: Plane = ...) -> None: ...
+    def arc_to(self, point: Vec2, radius: float, *, long: bool = ...) -> Sketch:
+        """Draw the arc of `radius` from the current point to `point`."""
+        ...
+    def arc_via(self, via: Vec2, point: Vec2) -> Sketch:
+        """Draw the arc from the current point through `via` to `point`."""
+        ...
+    def bounds(self) -> tuple[Vec3, Vec3]:
+        """The extents of the finished loops, in kernel.bounding_box's form."""
+        ...
+    def circle(self, centre: Vec2, radius: float, *, linetype: str | None = ...) -> Sketch:
+        """Draw a whole circle as four quarter arcs, counter-clockwise."""
+        ...
+    def close(self, *, linetype: str | None = ...) -> Sketch:
+        """Join the last point back to the first and finish the current loop."""
+        ...
+    def ellipse(self, centre: Vec2, major: float, minor: float, angle: float = ..., *, linetype: str | None = ...) -> Sketch:
+        """Draw a whole ellipse about `centre`, a loop of its own."""
+        ...
+    def ellipse_arc(self, centre: Vec2, major: float, minor: float, angle: float, start: Vec2, end: Vec2, *, linetype: str | None = ...) -> Sketch:
+        """Draw the piece of an ellipse from `start` anticlockwise to `end` (item 437)."""
+        ...
+    def end(self, *, linetype: str | None = ...) -> Sketch:
+        """Finish the loop being drawn where it is, leaving it open (item 422)."""
+        ...
+    def ended(self) -> tuple[int, ...]:
+        """Which of loops() end() finished open, by index (item 422)."""
+        ...
+    def extrude(self, height: float) -> Shape:
+        """Sweep the capped profile off its own plane by `height`."""
+        ...
+    def face(self) -> Shape:
+        """Cap the profile with a planar face on the sketch plane."""
+        ...
+    def faces(self) -> list[Shape]:
+        """Every face the closed loops bound, each loop inside another a hole in it."""
+        ...
+    @property
+    def is_closed(self) -> bool: ...
+    def line_to(self, point: Vec2) -> Sketch:
+        """Draw a straight segment from the current point to `point`."""
+        ...
+    def linetypes(self) -> tuple[str, ...]:
+        """Each loop's linetype, aligned with loops(), continuous unless given (item 573)."""
+        ...
+    @property
+    def loop_count(self) -> int: ...
+    def loops(self) -> tuple[tuple[tuple[str, ...], ...], ...]:
+        """Every loop drawn so far: the finished ones, then the one being drawn."""
+        ...
+    def meets_x_axis(self, samples: int = ...) -> tuple[list[Vec2], list[tuple[Vec2, Vec2]]]:
+        """Where the closed loops meet the plane's own x axis (item 835)."""
+        ...
+    def move_to(self, point: Vec2) -> Sketch:
+        """Put the pen down at `point`, starting the loop it belongs to."""
+        ...
+    def path(self) -> Shape:
+        """Everything drawn, as one open wire: the path a sweep follows."""
+        ...
+    @property
+    def plane(self) -> Plane: ...
+    def polygon(self, centre: Vec2, radius: float, sides: int, *, linetype: str | None = ...) -> Sketch:
+        """Draw a regular n-gon on the circle of `radius` about `centre`."""
+        ...
+    def rectangle(self, corner: Vec2, opposite: Vec2, *, linetype: str | None = ...) -> Sketch:
+        """Draw a whole axis-aligned rectangle between two opposite corners."""
+        ...
+    def revolve(self, point: Vec3, direction: Vec3, angle: float = ...) -> Shape:
+        """Sweep the capped profile about an axis, via kernel.revolve."""
+        ...
+    def rounded_rectangle(self, corner: Vec2, opposite: Vec2, radius: float, *, linetype: str | None = ...) -> Sketch:
+        """Draw a rectangle with its four corners rounded to `radius`."""
+        ...
+    def set_linetype(self, loop: int, linetype: str) -> Sketch:
+        """Draw finished loop `loop` in `linetype`, one of LINETYPES (item 573)."""
+        ...
+    def slot(self, start: Vec2, end: Vec2, width: float, *, linetype: str | None = ...) -> Sketch:
+        """Draw a rounded slot of `width` centred on the line start to end."""
+        ...
+    def spline(self, points: list[Vec2]) -> Sketch:
+        """Draw a smooth curve from the current point through each of `points`."""
+        ...
+    def spline_piece(self, points: list[Vec2], start: Vec2, end: Vec2, *, linetype: str | None = ...) -> Sketch:
+        """Draw the piece of the spline through `points` from `start` to `end` (item 437)."""
+        ...
+    def wire(self) -> Shape:
+        """The closed wire of the outline. Raises SketchError if it is open."""
+        ...
+
+class SketchError(RuntimeError):
+    """A sketch is not a usable profile: open, too short, or crossing itself."""
+
+class SweepError(RuntimeError):
+    """A sweep along a path did not produce one valid solid."""
+
+class Tangent:
+    """The line through a and b touches the circle of centre c through rim point d."""
+    a: str
+    b: str
+    c: str
+    d: str
+    def __init__(self, a: str, b: str, c: str, d: str) -> None: ...
+
+class Touch:
+    """The circle of centre a through b touches the circle of centre c through d."""
+    a: str
+    b: str
+    c: str
+    d: str
+    inside: bool
+    def __init__(self, a: str, b: str, c: str, d: str, inside: bool = ...) -> None: ...
+
+class Vertical:
+    """Points a and b at the same x."""
+    a: str
+    b: str
+    def __init__(self, a: str, b: str) -> None: ...
+
+def angle_between(a: Shape, b: Shape) -> float:
+    """The angle in degrees between the normals of two planar faces, 0 to 180."""
+    ...
+
+def base_flange(points: Any, spec: SheetSpec, plane: Plane = ..., holes: Any = ..., cutouts: Any = ..., corner_treatment: str | None = ..., corner_gap: float | None = ...) -> SheetPart:
+    """A base flange: the closed profile on `plane`, `spec.thickness` thick."""
+    ...
+
+def blendable_edges(shape: Shape) -> list[Shape]:
+    """The edges of a shape a fillet or a chamfer could act on."""
+    ...
+
+def bounding_box(shape: Shape) -> tuple[Vec3, Vec3]:
+    """Axis-aligned extents of a shape as ((xmin, ymin, zmin), (xmax, ymax, zmax))."""
+    ...
+
+def centre_of_mass(shape: Shape) -> Vec3:
+    """Where a shape balances: the centroid of its volume, area or length."""
+    ...
+
+def chamfer(solid: Shape, distance: float, edges: Any = ...) -> Shape:
+    """Cut a symmetric flat across the given edges of a solid."""
+    ...
+
+def chamfer_all(solid: Shape, distance: float) -> Shape:
+    """Cut a flat across every edge of a solid at once, as fillet_all rounds them."""
+    ...
+
+def checked_linetype(linetype: object) -> str:
+    """`linetype` as one of LINETYPES, any case; ValueError naming them otherwise."""
+    ...
+
+def circular_pattern(shape: Shape, point: Vec3, direction: Vec3, count: int, angle: float = ...) -> list[Shape]:
+    """`count` copies of a shape, spread about the axis (point, direction)."""
+    ...
+
+def closest_points(a: Shape, b: Shape) -> tuple[Vec3, Vec3]:
+    """Where the gap between two shapes is measured: the point on each."""
+    ...
+
+def common(a: Shape, b: Shape) -> Shape:
+    """The overlap of a and b."""
+    ...
+
+def compound(shapes: Any) -> Shape:
+    """One shape holding every shape given, so a pattern can be carried as a unit."""
+    ...
+
+def constrained(plane: Plane, points: list[Vec2], constraints: list[Horizontal | Vertical | Coincident | Distance | Radius | Diameter | Tangent | Touch | Concentric | Equal], circles: list[tuple[Vec2, Vec2]] = ..., arcs: dict[int, Vec2] | None = ...) -> Sketch:
+    """A closed polyline through `points`, moved until `constraints` all hold."""
+    ...
+
+def copy(shape: Shape) -> Shape:
+    """An independent copy of a shape, sharing no geometry with it."""
+    ...
+
+def counterbore(solid: Shape, face: Shape, centre: Vec2 | None, radius: float, head_radius: float, head_depth: float, depth: float | None = ..., *, world: Vec3 | None = ...) -> Shape:
+    """Drill a hole with the flat-bottomed bore a socket head sits in above it."""
+    ...
+
+def countersink(solid: Shape, face: Shape, centre: Vec2 | None, radius: float, head_radius: float, depth: float | None = ..., *, world: Vec3 | None = ...) -> Shape:
+    """Drill a hole with the cone a countersunk screw head sits in above it."""
+    ...
+
+def cross_section(shape: Shape, plane: Plane) -> list[Shape]:
+    """The planar faces where `plane` meets `shape`, in explorer order."""
+    ...
+
+def cut(a: Shape, b: Shape) -> Shape:
+    """a with b removed from it."""
+    ...
+
+def cut_all(base: Shape, tools: Any) -> Shape:
+    """`base` with every tool cut out of it, in the order given."""
+    ...
+
+def din_k_factor(bend_radius: float, thickness: float) -> float:
+    """The K-factor DIN 6935 gives a bend of this inside radius in this sheet (item 545)."""
+    ...
+
+def distance(a: Shape, b: Shape) -> float:
+    """The shortest gap between two shapes, in model units."""
+    ...
+
+def draft(solid: Shape, faces: Any, angle: float, neutral_plane: Plane) -> Shape:
+    """Tilt each named face by `angle` degrees about where it meets a plane."""
+    ...
+
+def drill_centre(plane: Plane, centre: Vec2 | None, world: Vec3 | None, what: str = ...) -> Vec2:
+    """Where a drill goes in the face's own coordinates, from whichever centre was given."""
+    ...
+
+def edges(shape: Shape) -> list[Shape]:
+    """Every distinct edge of a shape, in explorer order."""
+    ...
+
+def edges_parallel_to(shape: Shape, direction: Vec3, tol: float = ...) -> list[Shape]:
+    """The straight edges of a shape whose line runs parallel to `direction`."""
+    ...
+
+def explode(shapes: Any, factor: float) -> list[Shape]:
+    """Copies of `shapes` moved apart for an exploded view, as explode_offsets says."""
+    ...
+
+def explode_offsets(shapes: Any, factor: float) -> list[Vec3]:
+    """How far explode moves each of `shapes`, in order, as (x, y, z)."""
+    ...
+
+def extrude(face: Shape, height: float, direction: Vec3 = ...) -> Shape:
+    """Sweep a face by `height` along `direction` and return the solid."""
+    ...
+
+def face_count(shape: Shape) -> int:
+    """Number of faces in a shape."""
+    ...
+
+def face_plane(face: Shape) -> tuple[Vec3, Vec3]:
+    """The (point, normal) of a planar face, with the normal pointing outwards."""
+    ...
+
+def faces(shape: Shape) -> list[Shape]:
+    """Every distinct face of a shape, in explorer order."""
+    ...
+
+def faces_parallel_to(shape: Shape, direction: Vec3, tolerance: float = ...) -> list[Shape]:
+    """The planar faces of a shape whose outward normal points along `direction`."""
+    ...
+
+def fillet(solid: Shape, radius: float, edges: Any = ...) -> Shape:
+    """Round the given edges of a solid with a constant radius."""
+    ...
+
+def fillet_all(solid: Shape, radius: float) -> Shape:
+    """Round every edge of a solid at once, which is what a cast part wants."""
+    ...
+
+def flange(part: SheetPart, edge: int | tuple[int, str], length: float, angle: float = ..., direction: str = ..., start_inset: float = ..., end_inset: float = ..., relief: bool = ..., bend_radius: float | None = ..., holes: Any = ..., return_length: float = ..., cutouts: Any = ..., length_from: str = ..., corner_treatment: str | dict | None = ..., corner_gap: float | None = ..., return_angle: float = ..., return_direction: str = ..., hem: str | None = ..., teardrop_radius: float | None = ...) -> SheetPart:
+    """A new SheetPart with a flange bent `angle` degrees on `edge`: a profile edge or a flange's."""
+    ...
+
+def flat_pattern(part: SheetPart) -> FlatPattern:
+    """The flat pattern of a sheet part, worked out from its record, not its geometry."""
+    ...
+
+def flat_solid(pattern: FlatPattern) -> Shape:
+    """The flat pattern as a solid, for a CAM program that wants one (item 524)."""
+    ...
+
+def fuse(a: Shape, b: Shape) -> Shape:
+    """The union of a and b, with touching coplanar faces merged into one face."""
+    ...
+
+def fuse_all(shapes: Any) -> Shape:
+    """The union of every shape given, fused left to right."""
+    ...
+
+def hole(solid: Shape, face: Shape, centre: Vec2 | None, radius: float, depth: float | None = ..., *, world: Vec3 | None = ...) -> Shape:
+    """Drill a round hole into `solid` through one of its planar faces."""
+    ...
+
+def hollow(solid: Shape, thickness: float, faces: Any) -> Shape:
+    """Shell a solid to a constant wall thickness, leaving `faces` open."""
+    ...
+
+def hollow_facing(solid: Shape, thickness: float, directions: Any) -> Shape:
+    """hollow, the faces left open named by the way each faces (item 578)."""
+    ...
+
+def identity(name: str, part_number: str | None = ..., revision: str | None = ..., properties: dict[str, str] | None = ...) -> None:
+    """Give part `name` its part number, revision and properties (item 697)."""
+    ...
+
+def import_brep(path: Any) -> Shape:
+    """Read a BREP file back into one shape."""
+    ...
+
+def import_step(path: Any) -> Shape:
+    """Read a STEP file back into one shape."""
+    ...
+
+def inertia(shape: Shape) -> tuple[float, float, float]:
+    """The three principal moments of inertia, about the shape's centre of mass."""
+    ...
+
+def is_valid(shape: Shape) -> bool:
+    """Whether OCCT calls a shape sound, from BRepCheck_Analyzer."""
+    ...
+
+def linear_pattern(shape: Shape, step: Vec3, count: int) -> list[Shape]:
+    """`count` copies of a shape, each one `step` further along than the last."""
+    ...
+
+def loft(profiles: Any) -> Shape:
+    """Build one ruled solid through a sequence of closed profiles, in order."""
+    ...
+
+def make_box(dx: float, dy: float, dz: float, origin: tuple[float, float, float] = ...) -> Shape:
+    """Axis-aligned box of size dx * dy * dz with its min corner at origin."""
+    ...
+
+def make_cone(bottom_radius: float, top_radius: float, height: float, origin: tuple[float, float, float] = ...) -> Shape:
+    """Cone or frustum of the given radii and height, along +Z."""
+    ...
+
+def make_cylinder(radius: float, height: float, origin: tuple[float, float, float] = ...) -> Shape:
+    """Cylinder of the given radius and height, extruded along +Z."""
+    ...
+
+def make_sphere(radius: float, origin: tuple[float, float, float] = ...) -> Shape:
+    """Sphere of the given radius, centred on origin."""
+    ...
+
+def make_torus(major_radius: float, minor_radius: float, origin: tuple[float, float, float] = ...) -> Shape:
+    """Torus of the given radii, its ring centred on origin and its axis +Z."""
+    ...
+
+def make_wire(edges: Any) -> Shape:
+    """One wire built from a sequence of edges, whatever order they are given in."""
+    ...
+
+def mate(part: str, ref: str, to: str, to_ref: str, kind: str, value: Any = ...) -> Shape:
+    """Place part `part` against part `to` by one mate (item 575), and give it back placed."""
+    ...
+
+def min_wall_thickness(shape: Shape, samples: int = ...) -> tuple[float, Vec3]:
+    """The thinnest wall of a solid and the point on its surface it was measured from."""
+    ...
+
+def mirror(shape: Shape, point: Vec3, normal: Vec3) -> Shape:
+    """A copy of shape reflected in the plane through `point` with `normal`."""
+    ...
+
+def outermost_face(shape: Shape, direction: Vec3) -> Shape:
+    """The planar face of a shape facing `direction` that lies furthest along it."""
+    ...
+
+def outline(shape: Shape, plane: Plane) -> list[Shape]:
+    """The section of `shape` at `plane`, as wires rather than loose edges."""
+    ...
+
+def overhang_faces(shape: Shape, angle: float = ..., up: Vec3 = ...) -> list[Shape]:
+    """The faces a printer would have to bridge or support, printing along `up`."""
+    ...
+
+def part(name: str, shape: Shape, color: str | None = ..., part_number: str | None = ..., revision: str | None = ..., properties: dict[str, str] | None = ...) -> Shape:
+    """Register `shape` as the project entry `name` and give it back."""
+    ...
+
+def place(name: str, source: Any, at: Any = ..., rotate: Any = ..., part: Any = ...) -> Shape:
+    """Put `source` in as the part `name`, turned by `rotate` and moved to `at` (item 453)."""
+    ...
+
+def polygon_face(points: Any, plane: Plane = ...) -> Shape:
+    """Planar face on `plane` bounded by the polygon through `points`."""
+    ...
+
+def rename(old: str, new: str) -> None:
+    """Give part `old`, registered already, the name `new` (item 711)."""
+    ...
+
+def revolve(face: Shape, point: Vec3, direction: Vec3, angle: float = ...) -> Shape:
+    """Sweep a face `angle` degrees about the axis (point, direction)."""
+    ...
+
+def rotate(shape: Shape, point: Vec3, direction: Vec3, angle: float) -> Shape:
+    """A copy of shape turned `angle` degrees about the axis (point, direction)."""
+    ...
+
+def scale(shape: Shape, factor: float, origin: Vec3 = ...) -> Shape:
+    """A copy of shape enlarged about `origin` by `factor`. The input is left alone."""
+    ...
+
+def section(shape: Shape, plane: Plane) -> list[Shape]:
+    """The edges where `plane` cuts `shape`, in explorer order."""
+    ...
+
+def sheet_part(kind: str, *args: object, **kwargs: object) -> SheetPart:
+    """A plugin's kind of sheet part (item 604): `kind` is "PLUGIN.NAME"."""
+    ...
+
+def size(shape: Shape) -> float:
+    """How big a shape is in the one measure its kind has."""
+    ...
+
+def slices(shape: Shape, plane: Plane, step: float) -> list[tuple[float, list[Shape]]]:
+    """The cross-sections at `plane` and at every `step` along its normal."""
+    ...
+
+def solid_count(shape: Shape) -> int:
+    """Number of solids in a shape."""
+    ...
+
+def solids(shape: Shape) -> list[Shape]:
+    """Every distinct solid of a shape, in explorer order."""
+    ...
+
+def split(shape: Shape, plane: Plane) -> list[Shape]:
+    """Cut `shape` with `plane` and return the pieces."""
+    ...
+
+def stock_box(shape: Shape, margin: float = ...) -> Shape:
+    """The blank `shape` is cut from: its bounding box grown by `margin`, as a solid."""
+    ...
+
+def surface_area(shape: Shape) -> float:
+    """Total area of every face of a shape, in model units squared."""
+    ...
+
+def sweep(profile: Shape, path: Shape) -> Shape:
+    """Sweep a face along a wire and return the one solid it encloses."""
+    ...
+
+def text3d(text: str, size: float, depth: float, font: str | None = ..., plane: Plane = ..., at: Vec2 = ..., angle: float = ..., align: str = ...) -> Shape:
+    """The letters of `text` as a solid: `size` high at the capitals, `depth` deep."""
+    ...
+
+def translate(shape: Shape, vector: Vec3) -> Shape:
+    """A copy of shape moved by vector. The input is left alone."""
+    ...
+
+def use(path: Any, part: str | None = ..., as_group: bool = ...) -> Any:
+    """The parts another part or assembly file's model builds, by name, or the one named (item 576)."""
+    ...
+
+def vertices(shape: Shape) -> list[Shape]:
+    """Every distinct vertex of a shape, in explorer order."""
+    ...
+
+def volume(shape: Shape) -> float:
+    """Enclosed volume of a solid, in model units cubed."""
+    ...
+
+def wires(shape: Shape) -> list[Shape]:
+    """Every distinct wire of a shape, in explorer order."""
+    ...
+
+def write_flat(flat: FlatPattern, path: Any) -> Any:
+    """Write a FlatPattern to `path`, a .dxf or a .svg, as `dxcad flat` writes one (item 762)."""
+    ...

dxcad-stubs/py.typed

@@ -0,0 +1 @@
+partial