fluidcad 0.0.2

package/lib/dist/core/load.d.ts

@@ -0,0 +1,10 @@
+import { ISceneObject } from "./interfaces.js";
+interface LoadFunction {
+    /**
+     * Loads a 3D model file (STEP, STL, etc.) by filename.
+     * @param fileName - The path to the model file
+     */
+    (fileName: string): ISceneObject;
+}
+declare const _default: LoadFunction;
+export default _default;

package/lib/dist/core/load.js

@@ -0,0 +1,10 @@
+import { registerBuilder } from "../index.js";
+import { LoadFile } from "../features/load.js";
+function build(context) {
+    return function load() {
+        const obj = new LoadFile(arguments[0]);
+        context.addSceneObject(obj);
+        return obj;
+    };
+}
+export default registerBuilder(build);

package/lib/dist/core/loft.d.ts

@@ -0,0 +1,10 @@
+import { ILoft, ISceneObject } from "./interfaces.js";
+interface LoftFunction {
+    /**
+     * Creates a loft between two or more profiles.
+     * @param profiles - The profiles to loft between (minimum 2)
+     */
+    (...profiles: ISceneObject[]): ILoft;
+}
+declare const _default: LoftFunction;
+export default _default;

package/lib/dist/core/loft.js

@@ -0,0 +1,21 @@
+import { registerBuilder } from "../index.js";
+import { Loft } from "../features/loft.js";
+function build(context) {
+    return function loft(...args) {
+        let faces;
+        if (args.length === 1 && Array.isArray(args[0])) {
+            faces = args[0];
+        }
+        else {
+            faces = args;
+        }
+        if (faces.length < 2) {
+            throw new Error("Loft requires at least two profiles.");
+        }
+        context.addSceneObjects(faces);
+        const result = new Loft(...faces);
+        context.addSceneObject(result);
+        return result;
+    };
+}
+export default registerBuilder(build);

package/lib/dist/core/mirror.d.ts

@@ -0,0 +1,40 @@
+import { PlaneLike } from "../math/plane.js";
+import { AxisLike } from "../math/axis.js";
+import { ISceneObject } from "./interfaces.js";
+interface MirrorFunction {
+    /**
+    * [2D] Mirror all sketch geometries across a given line.
+    * @param line The line to mirror across
+    */
+    (line: ISceneObject): ISceneObject;
+    /**
+    * [2D] Mirror all sketch geometries across a given axis.
+    * @param axis The axis to mirror across
+    */
+    (axis: AxisLike): ISceneObject;
+    /**
+    * [2D] Mirror given sketch geometries across a given line.
+    * @param line The line to mirror across
+    * @param geometries The geometries to mirror
+    */
+    (line: ISceneObject, ...geometries: ISceneObject[]): ISceneObject;
+    /**
+    * [2D] Mirror given sketch geometries across a given axis.
+    * @param axis The axis to mirror across
+    * @param geometries The geometries to mirror
+    */
+    (axis: AxisLike, ...geometries: ISceneObject[]): ISceneObject;
+    /**
+    * [3D] Mirror all scene shapes across a given plane.
+    * @param plane The plane to mirror across
+    */
+    (plane: PlaneLike): ISceneObject;
+    /**
+    * [3D] Mirror given shapes across a given plane.
+    * @param plane The plane to mirror across
+    * @param objects The shapes to mirror
+    */
+    (plane: PlaneLike, ...objects: ISceneObject[]): ISceneObject;
+}
+declare const _default: MirrorFunction;
+export default _default;

package/lib/dist/core/mirror.js

@@ -0,0 +1,95 @@
+import { registerBuilder } from "../index.js";
+import { normalizeAxis, normalizePlane } from "../helpers/normalize.js";
+import { SceneObject } from "../common/scene-object.js";
+import { MirrorShape } from "../features/mirror-shape.js";
+import { PlaneObjectBase } from "../features/plane-renderable-base.js";
+import { PlaneObject } from "../features/plane.js";
+import { isAxisLike } from "../math/axis.js";
+import { MirrorShape2D } from "../features/mirror-shape2d.js";
+import { AxisObjectBase } from "../features/axis-renderable-base.js";
+import { AxisObject } from "../features/axis.js";
+import { AxisFromEdge } from "../features/axis-from-edge.js";
+function build(context) {
+    return function mirror() {
+        if (arguments.length === 1) {
+            if (isAxisLike(arguments[0] || arguments[0] instanceof SceneObject)) {
+                let axis = null;
+                if (arguments[0] instanceof AxisObjectBase) {
+                    axis = arguments[0];
+                }
+                else if (arguments[0] instanceof SceneObject) {
+                    const line = arguments[0];
+                    axis = new AxisFromEdge(line);
+                    context.addSceneObject(axis);
+                }
+                else {
+                    const a = normalizeAxis(arguments[0]);
+                    axis = new AxisObject(a);
+                    context.addSceneObject(axis);
+                }
+                const mirror = new MirrorShape2D(axis);
+                context.addSceneObject(mirror);
+                return mirror;
+            }
+            else {
+                const pln = arguments[0];
+                let planeObj;
+                if (!(pln instanceof PlaneObjectBase)) {
+                    const normalizedPlane = normalizePlane(arguments[0]);
+                    planeObj = new PlaneObject(normalizedPlane);
+                    context.addSceneObject(planeObj);
+                }
+                else {
+                    planeObj = pln;
+                    ;
+                }
+                const mirror = new MirrorShape(planeObj);
+                context.addSceneObject(mirror);
+                return mirror;
+            }
+        }
+        if (arguments.length >= 2) {
+            const args = Array.from(arguments);
+            // 2D mirror with target objects: mirror(axis/line, geometries[])
+            if (isAxisLike(args[0]) || args[0] instanceof SceneObject) {
+                let axis = null;
+                if (args[0] instanceof AxisObjectBase) {
+                    axis = args[0];
+                }
+                else if (args[0] instanceof SceneObject) {
+                    const line = args[0];
+                    axis = new AxisFromEdge(line);
+                    context.addSceneObject(axis);
+                }
+                else {
+                    const a = normalizeAxis(args[0]);
+                    axis = new AxisObject(a);
+                    context.addSceneObject(axis);
+                }
+                const targetObjects = args.slice(1);
+                const mirror = new MirrorShape2D(axis, targetObjects);
+                if (!(args[0] instanceof AxisObjectBase) && !(args[0] instanceof SceneObject)) {
+                    context.addSceneObject(axis);
+                }
+                context.addSceneObject(mirror);
+                return mirror;
+            }
+            // 3D shape mirror: mirror(plane, ...objects)
+            const targetObjects = args.slice(1);
+            let planeObj;
+            if (!(args[0] instanceof PlaneObjectBase)) {
+                const normalizedPlane = normalizePlane(args[0]);
+                planeObj = new PlaneObject(normalizedPlane);
+                context.addSceneObject(planeObj);
+            }
+            else {
+                planeObj = args[0];
+            }
+            const mirror = new MirrorShape(planeObj, targetObjects);
+            context.addSceneObject(mirror);
+            return mirror;
+        }
+        throw new Error("Invalid arguments for mirror function");
+    };
+}
+export default registerBuilder(build);

package/lib/dist/core/part.d.ts

@@ -0,0 +1,7 @@
+export type PartHandle<T = any> = {
+    __fluidcad_part: true;
+    name: string;
+    _callback: (options: T) => void;
+};
+declare function part<T = any>(name: string, callback: (options: T) => void): PartHandle<T>;
+export default part;

package/lib/dist/core/part.js

@@ -0,0 +1,29 @@
+import { captureSourceLocation } from "../index.js";
+import { getCurrentScene, getCurrentFile } from "../scene-manager.js";
+import { Part } from "../features/part.js";
+function part(name, callback) {
+    const handle = {
+        __fluidcad_part: true,
+        name,
+        _callback: callback,
+    };
+    const sourceLocation = captureSourceLocation();
+    const currentFile = getCurrentFile();
+    const isDirectEdit = sourceLocation
+        && currentFile
+        && sourceLocation.filePath.replace('virtual:live-render:', '') === currentFile;
+    if (isDirectEdit) {
+        const scene = getCurrentScene();
+        if (scene) {
+            const partObj = new Part(name);
+            if (sourceLocation) {
+                partObj.setSourceLocation(sourceLocation);
+            }
+            scene.startProgressiveContainer(partObj);
+            callback(undefined);
+            scene.endProgressiveContainer();
+        }
+    }
+    return handle;
+}
+export default part;

package/lib/dist/core/plane.d.ts

@@ -0,0 +1,56 @@
+import { PlaneLike, PlaneTransformOptions } from "../math/plane.js";
+import { IPlane, ISceneObject } from "./interfaces.js";
+export type PlaneRenderableOptions = PlaneTransformOptions & {
+    sticky?: boolean;
+};
+interface PlaneFunction {
+    /**
+     * Creates a plane from a standard plane or normal vector.
+     * @param plane - The standard plane or normal vector
+     */
+    (plane: PlaneLike): IPlane;
+    /**
+     * Creates a plane with transform options.
+     * @param plane - The standard plane or normal vector
+     * @param options - Transform options (offset, flip, sticky, etc.)
+     */
+    (plane: PlaneLike, options: PlaneRenderableOptions): IPlane;
+    /**
+     * Creates a plane with an offset.
+     * @param plane - The standard plane or normal vector
+     * @param offset - The offset distance
+     */
+    (plane: PlaneLike, offset: number): IPlane;
+    /**
+     * Creates a plane from a face selection.
+     * @param selection - The selected face to create a plane from
+     */
+    (selection: ISceneObject): IPlane;
+    /**
+     * Creates a plane from a face selection with transform options.
+     * @param selection - The selected face to create a plane from
+     * @param options - Transform options (offset, flip, sticky, etc.)
+     */
+    (selection: ISceneObject, options: PlaneRenderableOptions): IPlane;
+    /**
+     * Creates a plane from a face selection with an offset.
+     * @param selection - The selected face to create a plane from
+     * @param offset - The offset distance
+     */
+    (selection: ISceneObject, offset: number): IPlane;
+    /**
+     * Transforms an existing plane with options.
+     * @param plane - The existing plane to transform
+     * @param options - Transform options (offset, flip, sticky, etc.)
+     */
+    (plane: IPlane, options: PlaneRenderableOptions): IPlane;
+    /**
+     * Creates a plane midway between two planes.
+     * @param p1 - The first plane
+     * @param p2 - The second plane
+     * @param options - Transform options (offset, flip, sticky, etc.)
+     */
+    (p1: PlaneLike | IPlane, p2: PlaneLike | IPlane, options?: PlaneRenderableOptions): IPlane;
+}
+declare const _default: PlaneFunction;
+export default _default;

package/lib/dist/core/plane.js

@@ -0,0 +1,111 @@
+import { normalizePlane } from "../helpers/normalize.js";
+import { registerBuilder } from "../index.js";
+import { isPlaneLike } from "../math/plane.js";
+import { PlaneObject } from "../features/plane.js";
+import { PlaneObjectBase } from "../features/plane-renderable-base.js";
+import { PlaneMiddleRenderable } from "../features/plane-mid.js";
+import { SceneObject } from "../common/scene-object.js";
+import { PlaneFromObject } from "../features/plane-from-object.js";
+function build(context) {
+    return function plane() {
+        if (arguments.length === 1) {
+            if (arguments[0] instanceof SceneObject) {
+                context.addSceneObject(arguments[0]);
+                const pln = new PlaneFromObject(arguments[0]);
+                context.addSceneObject(pln);
+                return pln;
+            }
+            else {
+                const axis = normalizePlane(arguments[0]);
+                const pln = new PlaneObject(axis);
+                context.addSceneObject(pln);
+                return pln;
+            }
+        }
+        if (arguments.length === 2) {
+            if (typeof arguments[1] === 'number') {
+                const options = { offset: arguments[1] };
+                if (arguments[0] instanceof SceneObject) {
+                    context.addSceneObject(arguments[0]);
+                    const pln = new PlaneFromObject(arguments[0], options);
+                    context.addSceneObject(pln);
+                    return pln;
+                }
+                else if (isPlaneLike(arguments[0])) {
+                    const axis = normalizePlane(arguments[0]);
+                    const pln = new PlaneObject(axis, options);
+                    context.addSceneObject(pln);
+                    return pln;
+                }
+            }
+            if ((arguments[0] instanceof PlaneObjectBase || isPlaneLike(arguments[0])) &&
+                (arguments[1] instanceof PlaneObjectBase || isPlaneLike(arguments[1]))) {
+                // axis between two others
+                let a1;
+                let a2;
+                if (arguments[0] instanceof PlaneObjectBase) {
+                    a1 = arguments[0];
+                }
+                else {
+                    const axis = normalizePlane(arguments[0]);
+                    a1 = new PlaneObject(axis);
+                }
+                if (arguments[1] instanceof PlaneObjectBase) {
+                    a2 = arguments[1];
+                }
+                else {
+                    const axis = normalizePlane(arguments[1]);
+                    a2 = new PlaneObject(axis);
+                }
+                context.addSceneObject(a1);
+                context.addSceneObject(a2);
+                const pln = new PlaneMiddleRenderable(a1, a2);
+                context.addSceneObject(pln);
+                return pln;
+            }
+            else if (arguments[0] instanceof SceneObject) {
+                context.addSceneObject(arguments[0]);
+                const pln = new PlaneFromObject(arguments[0], arguments[1]);
+                context.addSceneObject(pln);
+                return pln;
+            }
+            else if (isPlaneLike(arguments[0])) {
+                const axis1 = normalizePlane(arguments[0]);
+                const options = arguments[1];
+                const pln = new PlaneObject(axis1, options);
+                context.addSceneObject(pln);
+                return pln;
+            }
+        }
+        if (arguments.length === 3) {
+            if ((arguments[0] instanceof PlaneObjectBase || isPlaneLike((arguments[0]))) &&
+                (arguments[1] instanceof PlaneObjectBase || isPlaneLike((arguments[1])))) {
+                // axis between two others with options
+                let a1;
+                let a2;
+                if (arguments[0] instanceof PlaneObjectBase) {
+                    a1 = arguments[0];
+                }
+                else {
+                    const axis = normalizePlane(arguments[0]);
+                    a1 = new PlaneObject(axis);
+                }
+                if (arguments[1] instanceof PlaneObjectBase) {
+                    a2 = arguments[1];
+                }
+                else {
+                    const axis = normalizePlane(arguments[1]);
+                    a2 = new PlaneObject(axis);
+                }
+                const options = arguments[2];
+                context.addSceneObject(a1);
+                context.addSceneObject(a2);
+                const pln = new PlaneMiddleRenderable(a1, a2, options);
+                context.addSceneObject(pln);
+                return pln;
+            }
+        }
+        throw new Error("Invalid arguments for plane function");
+    };
+}
+export default registerBuilder(build);

package/lib/dist/core/region.d.ts

@@ -0,0 +1,13 @@
+import { Point2DLike } from "../math/point.js";
+import { ISceneObject } from "./interfaces.js";
+interface RegionFunction {
+    /** Activates interactive region selection on the last sketch. */
+    (): ISceneObject;
+    /**
+     * Selects specific regions from the last sketch.
+     * @param points - 2D points inside the regions to select
+     */
+    (...points: Point2DLike[]): ISceneObject;
+}
+declare const _default: RegionFunction;
+export default _default;

package/lib/dist/core/region.js

@@ -0,0 +1,18 @@
+import { normalizePoint2D } from "../helpers/normalize.js";
+import { registerBuilder } from "../index.js";
+import { Region2D } from "../features/region2d.js";
+function build(context) {
+    return function region(...args) {
+        const extrudable = context.getLastExtrudable();
+        if (!extrudable) {
+            throw new Error("Region requires a preceding sketch or extrudable");
+        }
+        const region2d = new Region2D(extrudable);
+        if (args.length > 0) {
+            region2d.points(...args.map(p => normalizePoint2D(p)));
+        }
+        context.addSceneObject(region2d);
+        return region2d;
+    };
+}
+export default registerBuilder(build);

package/lib/dist/core/remove.d.ts

@@ -0,0 +1,10 @@
+import { ISceneObject } from "./interfaces.js";
+interface RemoveFunction {
+    /**
+     * Removes the given objects from the scene.
+     * @param objects - The objects to remove
+     */
+    (...objects: ISceneObject[]): ISceneObject;
+}
+declare const _default: RemoveFunction;
+export default _default;

package/lib/dist/core/remove.js

@@ -0,0 +1,10 @@
+import { registerBuilder } from "../index.js";
+import { Remove } from "../features/remove.js";
+function build(context) {
+    return function remove(...args) {
+        const remove = new Remove(args);
+        context.addSceneObject(remove);
+        return remove;
+    };
+}
+export default registerBuilder(build);

package/lib/dist/core/repeat.d.ts

@@ -0,0 +1,41 @@
+import { AxisLike } from "../math/axis.js";
+import { LinearRepeatOptions } from "../features/repeat-linear.js";
+import { CircularRepeatOptions } from "../features/repeat-circular.js";
+import { ISceneObject } from "./interfaces.js";
+import { PlaneLike } from "../math/plane.js";
+export type RepeatType = 'linear' | 'circular' | 'mirror';
+interface RepeatFunction {
+    /**
+     * Creates linear repeated instances along an axis.
+     * @param type - Must be `'linear'`
+     * @param axis - The axis to repeat along
+     * @param options - Repeat count, spacing, etc.
+     * @param objects - The objects to repeat (defaults to last object)
+     */
+    (type: 'linear', axis: AxisLike, options: LinearRepeatOptions, ...objects: ISceneObject[]): ISceneObject;
+    /**
+     * Creates linear repeated instances along multiple axes.
+     * @param type - Must be `'linear'`
+     * @param axis - The axes to repeat along
+     * @param options - Repeat count, spacing, etc.
+     * @param objects - The objects to repeat (defaults to last object)
+     */
+    (type: 'linear', axis: AxisLike[], options: LinearRepeatOptions, ...objects: ISceneObject[]): ISceneObject;
+    /**
+     * Creates circular repeated instances around an axis.
+     * @param type - Must be `'circular'`
+     * @param axis - The axis to repeat around
+     * @param options - Repeat count, angle, etc.
+     * @param objects - The objects to repeat (defaults to last object)
+     */
+    (type: 'circular', axis: AxisLike, options: CircularRepeatOptions, ...objects: ISceneObject[]): ISceneObject;
+    /**
+     * Creates a mirrored instance of objects across a plane.
+     * @param type - Must be `'mirror'`
+     * @param plane - The plane to mirror across
+     * @param objects - The objects to mirror (defaults to last object)
+     */
+    (type: 'mirror', plane: PlaneLike, ...objects: ISceneObject[]): ISceneObject;
+}
+declare const _default: RepeatFunction;
+export default _default;

package/lib/dist/core/repeat.js

@@ -0,0 +1,146 @@
+import { registerBuilder } from "../index.js";
+import { normalizeAxis, normalizePlane } from "../helpers/normalize.js";
+import { Matrix4 } from "../math/matrix4.js";
+import { rad } from "../helpers/math-helpers.js";
+import { RepeatLinear } from "../features/repeat-linear.js";
+import { RepeatCircular } from "../features/repeat-circular.js";
+import { cloneWithTransform } from "../helpers/clone-transform.js";
+import { PlaneObjectBase } from "../features/plane-renderable-base.js";
+import { PlaneObject } from "../features/plane.js";
+import { MirrorFeature } from "../features/mirror-feature.js";
+function build(context) {
+    return (function repeat() {
+        const args = Array.from(arguments);
+        if (args.length < 2) {
+            throw new Error("Invalid arguments for repeat function: expected at least (type, ...)");
+        }
+        const sketch = context.getActiveSketch();
+        if (sketch) {
+            throw new Error("Cannot call repeat() inside a sketch. Use copy() instead.");
+        }
+        const type = args[0];
+        if (type === 'linear' || type === 'circular') {
+            const axisArg = args[1];
+            const axes = Array.isArray(axisArg)
+                ? axisArg.map(a => normalizeAxis(a))
+                : [normalizeAxis(axisArg)];
+            const options = args[2];
+            const restObjects = args.slice(3);
+            const objects = restObjects.length > 0
+                ? restObjects
+                : [context.getSceneObjects().at(-1)];
+            if (type === 'linear') {
+                const counts = Array.isArray(options.count) ? options.count : [options.count];
+                const offsets = options.offset != null
+                    ? (Array.isArray(options.offset) ? options.offset : [options.offset])
+                    : null;
+                const lengths = 'length' in options && options.length != null
+                    ? (Array.isArray(options.length) ? options.length : [options.length])
+                    : null;
+                const repeat = new RepeatLinear(axes, options, objects);
+                const transformedObjects = [];
+                const axisOffsets = axes.map((axis, i) => {
+                    const count = counts[i] ?? counts[0];
+                    const offset = offsets != null
+                        ? (offsets[i] ?? offsets[0])
+                        : (lengths[i] ?? lengths[0]) / (count - 1);
+                    return { axis, count, offset };
+                });
+                // Generate all index combinations across axes
+                const indexCombinations = [[]];
+                for (const { count } of axisOffsets) {
+                    const newCombinations = [];
+                    for (const combo of indexCombinations) {
+                        for (let i = 0; i < count; i++) {
+                            newCombinations.push([...combo, i]);
+                        }
+                    }
+                    indexCombinations.length = 0;
+                    indexCombinations.push(...newCombinations);
+                }
+                for (const indices of indexCombinations) {
+                    // Skip the origin instance (all zeros)
+                    if (indices.every(i => i === 0)) {
+                        continue;
+                    }
+                    // Skip if in the skip list
+                    if (options.skip?.some(s => s.length === indices.length && s.every((v, i) => v === indices[i]))) {
+                        continue;
+                    }
+                    // Compose translation from all axes
+                    let dx = 0, dy = 0, dz = 0;
+                    for (let a = 0; a < axisOffsets.length; a++) {
+                        const { axis, offset } = axisOffsets[a];
+                        const idx = options.centered
+                            ? indices[a] - Math.floor(axisOffsets[a].count / 2)
+                            : indices[a];
+                        dx += axis.direction.x * offset * idx;
+                        dy += axis.direction.y * offset * idx;
+                        dz += axis.direction.z * offset * idx;
+                    }
+                    const transform = Matrix4.fromTranslation(dx, dy, dz);
+                    const cloned = cloneWithTransform(objects, transform, repeat);
+                    transformedObjects.push(...cloned);
+                }
+                context.addSceneObject(repeat);
+                context.addSceneObjects(transformedObjects);
+                return repeat;
+            }
+            if (type === 'circular') {
+                const axis = axes[0];
+                const circularOptions = options;
+                const { count, centered, skip } = circularOptions;
+                const repeat = new RepeatCircular(axis, circularOptions, objects);
+                let offset;
+                if ('offset' in circularOptions && circularOptions.offset !== undefined) {
+                    offset = circularOptions.offset;
+                }
+                else {
+                    offset = circularOptions.angle / (count - 1);
+                }
+                const startOffset = centered ? -(count * offset) / 2 : 0;
+                const transformedObjects = [];
+                for (let i = 1; i < count; i++) {
+                    if (skip?.includes(i)) {
+                        continue;
+                    }
+                    const angle = startOffset + offset * i;
+                    const matrix = Matrix4.fromRotationAroundAxis(axis.origin, axis.direction, rad(angle));
+                    const cloned = cloneWithTransform(objects, matrix, repeat);
+                    transformedObjects.push(...cloned);
+                }
+                context.addSceneObject(repeat);
+                context.addSceneObjects(transformedObjects);
+                return repeat;
+            }
+        }
+        if (type === 'mirror') {
+            const planeArg = args[1];
+            const restObjects = args.slice(2);
+            const targetObjects = restObjects.length > 0
+                ? restObjects
+                : [context.getSceneObjects().at(-1)];
+            let planeObj;
+            let normalizedPlane;
+            if (planeArg instanceof PlaneObjectBase) {
+                planeObj = planeArg;
+                planeObj.build();
+                normalizedPlane = planeObj.getPlane();
+            }
+            else {
+                normalizedPlane = normalizePlane(planeArg);
+                planeObj = new PlaneObject(normalizedPlane);
+                planeObj.build();
+                context.addSceneObject(planeObj);
+            }
+            const matrix = Matrix4.mirrorPlane(normalizedPlane.normal, normalizedPlane.origin);
+            const mirrorFeature = new MirrorFeature(planeObj, matrix);
+            const mirrorTree = cloneWithTransform(targetObjects, matrix, mirrorFeature);
+            context.addSceneObject(mirrorFeature);
+            context.addSceneObjects(mirrorTree);
+            return mirrorFeature;
+        }
+        throw new Error(`Invalid repeat type: ${type}`);
+    });
+}
+export default registerBuilder(build);

package/lib/dist/core/revolve.d.ts

@@ -0,0 +1,19 @@
+import { AxisLike } from "../math/axis.js";
+import { IRevolve, ISceneObject } from "./interfaces.js";
+interface RevolveFunction {
+    /**
+     * Revolves the last sketch 360 degrees around an axis.
+     * @param axisLike - The axis to revolve around
+     * @param target - The sketch to revolve
+     */
+    (axisLike: AxisLike, target?: ISceneObject): IRevolve;
+    /**
+     * Revolves the last sketch by a given angle around an axis.
+     * @param axisLike - The axis to revolve around
+     * @param angle - The sweep angle in degrees
+     * @param target - The sketch to revolve
+     */
+    (axisLike: AxisLike, angle: number, target?: ISceneObject): IRevolve;
+}
+declare const _default: RevolveFunction;
+export default _default;