opengeometry 2.0.13 → 2.0.14

package/src/export/analytic-ifc.d.ts

@@ -0,0 +1,61 @@
+export type IfcPreparedValue = {
+    kind: "Ref";
+    id: number;
+} | {
+    kind: "List";
+    values: IfcPreparedValue[];
+} | {
+    kind: "Real";
+    value: number;
+} | {
+    kind: "Integer";
+    value: number;
+} | {
+    kind: "Text" | "Enum";
+    value: string;
+} | {
+    kind: "Bool";
+    value: boolean;
+} | {
+    kind: "Null" | "Derived";
+};
+export interface AnalyticExchangeBodyV2 {
+    schema_version: 2;
+    revision: string;
+    length_unit: "metre";
+    up_axis: "Z";
+    coordinate_space: "world";
+    representation_type: "AdvancedBrep" | "CSG";
+    quality: {
+        kind: "Analytic";
+    } | {
+        kind: "Approximate";
+        max_error: number;
+    };
+    geometric_tolerance: number;
+    exchange_error_bound: number;
+    validation_level: string;
+    entities: {
+        id: number;
+        entity_type: string;
+        attributes: IfcPreparedValue[];
+    }[];
+    solids: number[];
+    faces: {
+        face: number;
+        key: string;
+        entity: number;
+        provenance: {
+            sources: {
+                entity: string;
+                body: string;
+                key: string;
+                face: number;
+            }[];
+            role: "Authored" | "Preserved" | "Split" | "Cut" | "Coincident";
+            reversed: boolean;
+        };
+    }[];
+}
+/** Serializes Rust-prepared geometry; this function does not fit curves or tessellate surfaces. */
+export declare function analyticIfcText(body: AnalyticExchangeBodyV2, name?: string): string;

package/src/freeform/geometry.d.ts

@@ -78,3 +78,5 @@ export declare class FreeformGeometry {
  * BRep object, or another wrapper exposing BRep accessors.
  */
 export declare function createFreeformGeometry(source: FreeformSource, options?: CreateFreeformGeometryOptions): FreeformGeometry;
+/** Triangulates an explicitly faceted BRep, including its planar face holes. */
+export declare function tessellateFacetedBrep(serialized: string): Float64Array;

package/src/freeform/index.d.ts

@@ -2,4 +2,4 @@
  * Freeform geometry types and helpers for working with raw BRep-backed models.
  */
 export * from "./types.js";
-export { FreeformGeometry, createFreeformGeometry } from "./geometry.js";
+export { FreeformGeometry, createFreeformGeometry, tessellateFacetedBrep } from "./geometry.js";

package/src/operations/analytic-errors.d.ts

@@ -0,0 +1,8 @@
+export type AnalyticGeometryErrorCode = "math" | "invalid_geometry" | "invalid_topology" | "unsupported_geometry" | "ambiguous_profile_alignment" | "coverage_gap" | "singular_parameterization" | "missing_reference" | "unsupported_schema" | "unresolved_intersection" | "unresolved_tessellation" | "limit_exceeded" | "unknown";
+export declare class AnalyticGeometryError extends Error {
+    readonly code: AnalyticGeometryErrorCode;
+    readonly detail: unknown;
+    readonly families?: readonly [string, string];
+    constructor(code: AnalyticGeometryErrorCode, message: string, detail?: unknown);
+}
+export declare function parseAnalyticGeometryError(raw: unknown): AnalyticGeometryError;

package/src/operations/boolean.d.ts

@@ -1,148 +1,16 @@
 import * as THREE from "three";
-import { type CreateFreeformGeometryOptions, type FreeformGeometry } from "../freeform.js";
-/**
- * Accepted operand formats for boolean helpers.
- */
-export type BooleanOperand = string | Record<string, unknown> | {
-    getBrep?: () => unknown;
-    getBrepData?: () => unknown;
-    getBrepSerialized?: () => string;
-};
-/**
- * Kernel-side boolean tuning options.
- *
- * `tolerance` is in **model units** (meters by convention). When omitted, the
- * kernel auto-scales it to `operandsDiagonal * 1e-8` (clamped to a `1e-6`
- * floor in many-subtract). This drives the kernel-side polygon / face math
- * (vertex welding, plane coincidence, AABB enforcement).
- *
- * **NOTE: this tolerance does NOT control boolmesh's internal snap window.**
- * Boolmesh has its own welding tolerance that may treat faces within ~1mm
- * of each other as coincident, regardless of what `tolerance` you pass. If
- * your cutter face sits within about 0.001 m – 0.01 m of a host face you
- * may still hit a `DegenerateTriangle` / `CoincidentFaces` error path.
- *
- * **Recommended cutter overshoot for through-cuts:** `max(hostThickness *
- * 0.05, 0.01)` in model units. See `knowledge/boolean-tolerance-guide.md`.
- *
- * `mergeCoplanarFaces` (default `true`) controls whether the planar pipeline
- * merges coplanar adjacent faces in its output.
- */
-export interface BooleanKernelOptions {
-    tolerance?: number;
-    mergeCoplanarFaces?: boolean;
-}
-/**
- * Rendering options applied to the boolean result mesh.
- *
- * `color`, `opacity`, `transparent`, and `side` override the corresponding
- * fields on the host (LHS) operand's cloned material. Omit them to inherit
- * the host's appearance unchanged.
- */
-export interface BooleanRenderOptions {
+import { AnalyticSolid } from "../shapes/analytic-solid.js";
+/** Rendering and tessellation options applied to an analytic boolean result. */
+export interface BooleanExecutionOptions {
+    deflection?: number;
     color?: THREE.ColorRepresentation;
     opacity?: number;
     transparent?: boolean;
     side?: THREE.Side;
     outline?: boolean;
-    fatOutlines?: boolean;
-    outlineWidth?: number;
-}
-/**
- * Combined kernel and rendering options accepted by boolean helpers.
- */
-export interface BooleanExecutionOptions extends BooleanRenderOptions {
-    kernel?: BooleanKernelOptions;
-}
-/**
- * Structured report returned by the kernel boolean pipeline.
- */
-export interface BooleanReport {
-    operation: string;
-    operand_kind: string;
-    input_face_count: number;
-    input_triangle_count: number;
-    output_face_count: number;
-    output_shell_count: number;
-    empty: boolean;
-}
-interface KernelBooleanResult {
-    brepSerialized: string;
-    geometrySerialized: string;
-    outlineGeometrySerialized: string;
-    reportJson: string;
-}
-/**
- * Renderable result mesh returned by the kernel boolean helpers.
- */
-export declare class BooleanResult extends THREE.Mesh {
-    #private;
-    ogid: string;
-    report: BooleanReport | null;
-    private brepSerialized;
-    private brepData;
-    private outlinePositions;
-    private _outlineEnabled;
-    private _fatOutlines;
-    private _outlineWidth;
-    constructor(kernelResult: KernelBooleanResult, options?: BooleanRenderOptions, host?: BooleanOperand | null);
-    /**
-     * Updates the result mesh's color in place without re-running the boolean
-     * pipeline. Accepts any value Three.js accepts (`number`, hex string, css
-     * color name, or `THREE.Color`). No-op for materials without a `color` field.
-     */
-    set color(value: THREE.ColorRepresentation);
-    get color(): THREE.Color | null;
-    /**
-     * Rebuilds the mesh, cached BRep payload, and outline geometry from the kernel output.
-     */
-    applyKernelResult(kernelResult: KernelBooleanResult, options?: BooleanRenderOptions, sourceMaterial?: THREE.Material | null): void;
-    /**
-     * Returns the parsed BRep object for reuse with scene export or downstream operations.
-     */
-    getBrepData(): Record<string, unknown> | null;
-    /**
-     * Returns the serialized BRep JSON emitted by the kernel boolean operation.
-     */
-    getBrepSerialized(): string;
-    canConvertToFreeform(): boolean;
-    /**
-     * Converts the boolean output into a first-class freeform geometry object so
-     * it can participate in direct face/edge/vertex editing.
-     */
-    toFreeform(options?: CreateFreeformGeometryOptions): FreeformGeometry;
-    set outline(enable: boolean);
-    get outline(): boolean;
-    set fatOutlines(value: boolean);
-    get fatOutlines(): boolean;
-    set outlineWidth(value: number);
-    get outlineWidth(): number;
-    disposeGeometry(): void;
-    private clearOutlineMesh;
 }
-/**
- * Computes a kernel-backed boolean union and returns a renderable result mesh.
- *
- * Accepts wrapper objects directly, including `Solid`, `Cuboid`, `Opening`,
- * and other shapes that expose BRep accessors.
- */
-export declare function booleanUnion(lhs: BooleanOperand, rhs: BooleanOperand, options?: BooleanExecutionOptions): BooleanResult;
-/**
- * Computes a kernel-backed boolean intersection and returns a renderable result mesh.
- */
-export declare function booleanIntersection(lhs: BooleanOperand, rhs: BooleanOperand, options?: BooleanExecutionOptions): BooleanResult;
-/**
- * Computes a kernel-backed boolean subtraction and returns a renderable result mesh.
- *
- * Use this when you want a standalone helper rather than a shape-level
- * convenience method like `opening.subtractFrom(host)`.
- */
-export declare function booleanSubtraction(lhs: BooleanOperand, rhs: BooleanOperand, options?: BooleanExecutionOptions): BooleanResult;
-/**
- * Computes a kernel-backed repeated subtraction using a left-to-right cutter array.
- *
- * This is used by the shape-level `.subtract([...])` helpers so the heavy
- * boolean orchestration stays in the Rust/WASM layer instead of JavaScript.
- */
-export declare function executeBooleanSubtractionMany(lhs: BooleanOperand, cutters: BooleanOperand[], options?: BooleanExecutionOptions): BooleanResult;
-export {};
+export type BooleanOperand = AnalyticSolid;
+export declare function booleanUnion(lhs: AnalyticSolid, rhs: AnalyticSolid, options?: BooleanExecutionOptions): AnalyticSolid;
+export declare function booleanIntersection(lhs: AnalyticSolid, rhs: AnalyticSolid, options?: BooleanExecutionOptions): AnalyticSolid;
+export declare function booleanSubtraction(lhs: AnalyticSolid, rhs: AnalyticSolid, options?: BooleanExecutionOptions): AnalyticSolid;
+export declare function executeBooleanSubtractionMany(lhs: BooleanOperand, cutters: BooleanOperand[], options?: BooleanExecutionOptions): AnalyticSolid;

package/src/operations/index.d.ts

@@ -2,6 +2,7 @@
  * Kernel-backed boolean helpers and renderable result mesh.
  */
 export * from "./boolean.js";
-export * from "./boolean-errors.js";
+export * from "./analytic-errors.js";
 export * from "./extrude.js";
+export * from "./loft.js";
 export * from "./offset-regions.js";

package/src/operations/loft.d.ts

@@ -0,0 +1,13 @@
+import * as THREE from "three";
+import { AnalyticSolid, type AnalyticPolygonLoftAlignment } from "../shapes/analytic-solid.js";
+export type PolygonLoftPoint = readonly [number, number, number];
+export interface PolygonLoftOptions {
+    alignment?: AnalyticPolygonLoftAlignment;
+    deflection?: number;
+    color?: THREE.ColorRepresentation;
+}
+/**
+ * Creates a capped ruled solid between two planar polygon sections.
+ * Sections must have equal vertex counts and produce planar side faces.
+ */
+export declare function loftPolygonSections(sections: readonly [readonly PolygonLoftPoint[], readonly PolygonLoftPoint[]], options?: PolygonLoftOptions): AnalyticSolid;

package/src/primitives/analytic-curve.d.ts

@@ -0,0 +1,42 @@
+import * as THREE from "three";
+import { OGAnalyticBrep } from "../../opengeometry/pkg/opengeometry.js";
+import type { AnalyticAccuracy, AnalyticFrame } from "../shapes/analytic-solid.js";
+export type AnalyticCurveOptions = {
+    ogid?: string;
+    frame?: AnalyticFrame;
+    accuracy?: AnalyticAccuracy;
+    startAngle: number;
+    sweepAngle: number;
+    deflection?: number;
+    color?: THREE.ColorRepresentation;
+} & ({
+    kind: "arc";
+    radius: number;
+} | {
+    kind: "ellipticalArc";
+    majorRadius: number;
+    minorRadius: number;
+});
+export interface AnalyticCurveStats {
+    requestedDeflection: number;
+    achievedDeflection: number;
+    segmentCount: number;
+    revision: bigint;
+}
+export declare class AnalyticCurve extends THREE.Group {
+    readonly ogid: string;
+    readonly line: THREE.LineSegments<THREE.BufferGeometry, THREE.LineBasicMaterial>;
+    protected kernel: OGAnalyticBrep;
+    private segmentEdges;
+    private disposed;
+    get color(): THREE.Color;
+    set color(value: THREE.ColorRepresentation);
+    constructor(options: AnalyticCurveOptions);
+    getBrepSerialized(): string;
+    getBrepData(): Record<string, unknown>;
+    protected replaceDefinition(options: AnalyticCurveOptions): AnalyticCurveStats;
+    edgeIdForSegment(segment: number): number | undefined;
+    retessellate(deflection: number): AnalyticCurveStats;
+    dispose(): void;
+    private checkActive;
+}

package/src/primitives/arc.d.ts

@@ -1,65 +1,36 @@
-import { Vector3 } from "../../opengeometry/pkg/opengeometry.js";
 import * as THREE from "three";
-/**
- * Construction options for an arc or full-circle primitive.
- */
+import { Vector3 } from "../../opengeometry/pkg/opengeometry.js";
+import { AnalyticCurve, type AnalyticCurveStats } from "./analytic-curve.js";
+import type { AnalyticAccuracy } from "../shapes/analytic-solid.js";
 export interface IArcOptions {
+    ogid?: string;
+    center?: Vector3;
+    radius?: number;
+    startAngle?: number;
+    sweepAngle?: number;
+    deflection?: number;
+    accuracy?: AnalyticAccuracy;
+    color?: THREE.ColorRepresentation;
+}
+export type ArcConfigUpdate = Partial<Omit<IArcOptions, "ogid">>;
+interface NormalizedArcOptions {
     ogid?: string;
     center: Vector3;
     radius: number;
     startAngle: number;
-    endAngle: number;
-    segments: number;
-    color: number;
-    fatLines?: boolean;
-    width?: number;
-    translation?: Vector3;
-    rotation?: Vector3;
-    scale?: Vector3;
-}
-/**
- * Placement updates accepted by `Arc`.
- */
-export interface ArcPlacementOptions {
-    translation?: Vector3;
-    rotation?: Vector3;
-    scale?: Vector3;
+    sweepAngle: number;
+    deflection: number;
+    accuracy?: AnalyticAccuracy;
+    color: THREE.ColorRepresentation;
 }
-/**
- * Partial config payload accepted by `Arc.setConfig(...)`.
- */
-export type ArcConfigUpdate = Partial<Omit<IArcOptions, "translation" | "rotation" | "scale">>;
-/**
- * Alias for `Arc` placement updates.
- */
-export type ArcPlacementUpdate = ArcPlacementOptions;
-/**
- * Arc wrapper backed by the kernel OGArc primitive.
- */
-export declare class Arc extends THREE.Line {
-    ogid: string;
-    options: IArcOptions;
-    private arc;
-    private fatLine;
-    set color(color: number);
+/** Authoritative circular edge with transient deflection tessellation. */
+export declare class Arc extends AnalyticCurve {
+    options: Readonly<NormalizedArcOptions>;
     constructor(options?: IArcOptions);
-    validateOptions(): void;
-    setConfig(options: ArcConfigUpdate): void;
     getAnchor(): Vector3;
-    setPlacement(placement: ArcPlacementUpdate): void;
-    setTransform(translation: Vector3, rotation: Vector3, scale: Vector3): void;
-    setTranslation(translation: Vector3): void;
-    setRotation(rotation: Vector3): void;
-    setScale(scale: Vector3): void;
-    getConfig(): IArcOptions;
-    getPlacement(): import("../editor.js").ParametricPlacement;
-    getEditCapabilities(): import("../editor.js").ParametricEditCapabilities;
-    canConvertToFreeform(): boolean;
-    toFreeform(id?: string): import("../freeform.js").FreeformGeometry;
-    private getCurrentPositions;
-    private updateRenderStyle;
-    private generateGeometry;
-    getBrep(): any;
-    discardGeometry(): void;
-    private writePositionsToGeometry;
+    getConfig(): Readonly<NormalizedArcOptions>;
+    setConfig(update: ArcConfigUpdate): AnalyticCurveStats;
+    getBrep(): Record<string, unknown>;
+    retessellate(deflection: number): AnalyticCurveStats;
 }
+export {};

package/src/primitives/elliptical_arc.d.ts

@@ -1,66 +1,38 @@
-import { Vector3 } from "../../opengeometry/pkg/opengeometry.js";
 import * as THREE from "three";
-/**
- * Construction options for an elliptical arc primitive.
- */
+import { Vector3 } from "../../opengeometry/pkg/opengeometry.js";
+import { AnalyticCurve, type AnalyticCurveStats } from "./analytic-curve.js";
+import type { AnalyticAccuracy } from "../shapes/analytic-solid.js";
 export interface IEllipticalArcOptions {
+    ogid?: string;
+    center?: Vector3;
+    majorRadius?: number;
+    minorRadius?: number;
+    startAngle?: number;
+    sweepAngle?: number;
+    deflection?: number;
+    accuracy?: AnalyticAccuracy;
+    color?: THREE.ColorRepresentation;
+}
+export type EllipticalArcConfigUpdate = Partial<Omit<IEllipticalArcOptions, "ogid">>;
+interface NormalizedEllipticalArcOptions {
     ogid?: string;
     center: Vector3;
-    radiusX: number;
-    radiusZ: number;
+    majorRadius: number;
+    minorRadius: number;
     startAngle: number;
-    endAngle: number;
-    segments: number;
-    color: number;
-    fatLines?: boolean;
-    width?: number;
-    translation?: Vector3;
-    rotation?: Vector3;
-    scale?: Vector3;
-}
-/**
- * Placement updates accepted by `EllipticalArc`.
- */
-export interface EllipticalArcPlacementOptions {
-    translation?: Vector3;
-    rotation?: Vector3;
-    scale?: Vector3;
+    sweepAngle: number;
+    deflection: number;
+    accuracy?: AnalyticAccuracy;
+    color: THREE.ColorRepresentation;
 }
-/**
- * Partial config payload accepted by `EllipticalArc.setConfig(...)`.
- */
-export type EllipticalArcConfigUpdate = Partial<Omit<IEllipticalArcOptions, "translation" | "rotation" | "scale">>;
-/**
- * Alias for `EllipticalArc` placement updates.
- */
-export type EllipticalArcPlacementUpdate = EllipticalArcPlacementOptions;
-/**
- * EllipticalArc wrapper backed by the kernel OGEllipticalArc primitive.
- */
-export declare class EllipticalArc extends THREE.Line {
-    ogid: string;
-    options: IEllipticalArcOptions;
-    private ellipticalArc;
-    private fatLine;
-    set color(color: number);
+/** Authoritative elliptical edge with transient deflection tessellation. */
+export declare class EllipticalArc extends AnalyticCurve {
+    options: Readonly<NormalizedEllipticalArcOptions>;
     constructor(options?: IEllipticalArcOptions);
-    validateOptions(): void;
-    setConfig(options: EllipticalArcConfigUpdate): void;
     getAnchor(): Vector3;
-    setPlacement(placement: EllipticalArcPlacementUpdate): void;
-    setTransform(translation: Vector3, rotation: Vector3, scale: Vector3): void;
-    setTranslation(translation: Vector3): void;
-    setRotation(rotation: Vector3): void;
-    setScale(scale: Vector3): void;
-    getConfig(): IEllipticalArcOptions;
-    getPlacement(): import("../editor.js").ParametricPlacement;
-    getEditCapabilities(): import("../editor.js").ParametricEditCapabilities;
-    canConvertToFreeform(): boolean;
-    toFreeform(id?: string): import("../freeform.js").FreeformGeometry;
-    private getCurrentPositions;
-    private updateRenderStyle;
-    private generateGeometry;
-    getBrep(): any;
-    discardGeometry(): void;
-    private writePositionsToGeometry;
+    getConfig(): Readonly<NormalizedEllipticalArcOptions>;
+    setConfig(update: EllipticalArcConfigUpdate): AnalyticCurveStats;
+    getBrep(): Record<string, unknown>;
+    retessellate(deflection: number): AnalyticCurveStats;
 }
+export {};

package/src/rendering/analytic-lod.d.ts

@@ -0,0 +1,32 @@
+import * as THREE from "three";
+import type { AnalyticSolid, AnalyticTessellationStats } from "../shapes/analytic-solid.js";
+import { AnalyticTessellationWorker } from "./analytic-tessellation.js";
+export declare function deflectionBucket(target: number, previous?: number): number;
+export declare function worldUnitsPerPixel(camera: THREE.PerspectiveCamera | THREE.OrthographicCamera, depth: number, physicalHeight: number): number;
+export interface AnalyticLodOptions {
+    fixedDeflection?: number;
+    onUpdate?: (solid: AnalyticSolid, statistics: AnalyticTessellationStats) => void;
+    onError?: (solid: AnalyticSolid, error: Error) => void;
+}
+/** Register authored changes explicitly; camera meshes never refresh a scene's authored BRep snapshots. */
+export declare class AnalyticLodController {
+    private readonly worker;
+    private readonly options;
+    private readonly entries;
+    private readonly cameraState;
+    private lastMotion;
+    private lastSchedule;
+    private initialized;
+    private closed;
+    private refining;
+    private fixedDeflection?;
+    constructor(worker: AnalyticTessellationWorker, options?: AnalyticLodOptions);
+    setDeflection(deflection?: number): void;
+    register(solid: AnalyticSolid): Promise<void>;
+    unregister(solid: AnalyticSolid): Promise<void>;
+    update(camera: THREE.PerspectiveCamera | THREE.OrthographicCamera, physicalHeight: number, now?: number, motion?: boolean): void;
+    /** Explicit export refinement; a resource or precision failure rejects and retains each body's prior mesh. */
+    refine(deflection: number): Promise<void>;
+    dispose(): void;
+}
+export declare function uniformScale(matrix: THREE.Matrix4): number;

package/src/rendering/analytic-tessellation.d.ts

@@ -0,0 +1,32 @@
+export interface AnalyticTessellationData {
+    positions: Float64Array;
+    normals: Float32Array;
+    indices: Uint32Array;
+    triangleFaceIds: Uint32Array;
+    outlinePositions: Float64Array;
+    outlineEdgeIds: Uint32Array;
+    revision: bigint;
+    achievedDeflection: number;
+}
+export declare const GEOMETRY_DEFLECTION_SHARE = 0.75;
+export interface AnalyticWorkerOptions {
+    workerURL: string | URL;
+    kernelURL: string | URL;
+    wasmURL: string | URL;
+}
+export declare class AnalyticTessellationWorker {
+    private readonly worker;
+    private readonly pending;
+    private readonly generations;
+    private readonly ready;
+    private serial;
+    private closed;
+    constructor(options: AnalyticWorkerOptions);
+    setModel(handle: string, serialized: string): Promise<void>;
+    tessellate(handle: string, deflection: number): Promise<AnalyticTessellationData>;
+    cancel(handle: string): number;
+    removeModel(handle: string): Promise<void>;
+    dispose(): void;
+    private send;
+    private fail;
+}

package/src/shapes/analytic-pattern.d.ts

@@ -0,0 +1,36 @@
+import * as THREE from "three";
+import { AnalyticSolid } from "./analytic-solid.js";
+export interface AnalyticPatternInstance {
+    id?: string;
+    matrix: THREE.Matrix4;
+}
+export interface AnalyticPatternHit {
+    pattern: AnalyticPattern;
+    instanceIndex: number;
+    instanceId: string;
+    source: AnalyticSolid;
+    faceId?: number;
+}
+/**
+ * Renders many rigid placements of one authoritative analytic body. The source
+ * owns the BRep; instances own only identity and placement matrices.
+ */
+export declare class AnalyticPattern extends THREE.Group {
+    readonly source: AnalyticSolid;
+    readonly surface: THREE.InstancedMesh<THREE.BufferGeometry, THREE.Material>;
+    readonly instanceIds: readonly string[];
+    private disposed;
+    constructor(source: AnalyticSolid, instances: readonly AnalyticPatternInstance[]);
+    get count(): number;
+    setInstanceMatrix(index: number, matrix: THREE.Matrix4): void;
+    resolveIntersection(intersection: THREE.Intersection): AnalyticPatternHit | undefined;
+    dispose(): void;
+    private checkActive;
+}
+export declare function linearPattern(source: AnalyticSolid, count: number, spacing: THREE.Vector3): AnalyticPattern;
+export declare function rectangularPattern(source: AnalyticSolid, counts: readonly [number, number], spacing: readonly [THREE.Vector3, THREE.Vector3]): AnalyticPattern;
+export declare function circularPattern(source: AnalyticSolid, count: number, radius: number, options?: {
+    startAngle?: number;
+    sweepAngle?: number;
+    rotateInstances?: boolean;
+}): AnalyticPattern;