docs / Script API / KernelCadApi

KernelCadApi methods

69 unique methods generated from the typed runtime interface. Overloaded methods list each signature.

Task-based script API · Capability coverage inventory

angle(a: unknown, b: unknown): RequirementPredicate

animationView(spec: AnimationViewSpec): AnimationViewHandle

assembly(name?: string): Assembly

bbox(selection: unknown): RequirementPredicate

bezier(points: Vec3[]): Curve3D

box(x: Editable<number>, y: Editable<number>, z: Editable<number>, centered?: boolean, opts?: FaceLabelOpts): Shape

centerOfMass(selection: unknown): RequirementPredicate

clearance(a: unknown, b: unknown): RequirementPredicate

concentric(a: unknown, b: unknown): RequirementPredicate

coplanar(a: unknown, b: unknown): RequirementPredicate

count(selection: unknown): RequirementPredicate

curveBridge(a: Curve3D, b: Curve3D, opts: {
    continuity: 'G1' | 'G2';
    ends?: 'end-start' | 'end-end' | 'start-start' | 'start-end';
    tension?: number;
}): Curve3D

cylinder(h: Editable<number>, r: Editable<number>, segments?: number, opts?: FaceLabelOpts): Shape

dfmSpec(spec: DfmSpec): DfmSpecHandle

distance(a: unknown, b: unknown): RequirementPredicate

edges(shape: Shape, query?: EdgeQuery): RequirementSelectionHandle

extrudeCircle(r: Editable<number>, height: Editable<number>, opts?: ExtrudeOpts): Shape

extrudePolygon(points: Array<[
    Editable<number>,
    Editable<number>
]>, depth: Editable<number>, opts?: ExtrudeOpts): Shape

extrudeRect(w: Editable<number>, h: Editable<number>, height: Editable<number>, opts?: ExtrudeOpts): Shape

extrudeRoundedRect(width: Editable<number>, height: Editable<number>, radius: Editable<number>, depth: Editable<number>, opts?: ExtrudeOpts): Shape

faces(shape: Shape, query?: import('../shared/intent/queryTypes').FaceQuery): RequirementSelectionHandle

filletPolygon(points: readonly PolygonPoint[], radius: number, opts?: FilletPolygonOptions): [
    number,
    number
][]

fontPath(p: string): FontPath

helix(opts: EditableHelixOptions): RailPoint[]

hermiteG2(a: HermiteEndpoint, b: HermiteEndpoint): Curve3D

innerLoops(selection: unknown): RequirementPredicate

internalGear(opts: InternalSpurGearOptions): Shape

internalSpurGear(opts: InternalSpurGearOptions): Shape

isoThread(spec: string): IsoThreadInfo

mass(selection: unknown): RequirementPredicate

meta(metadata: AssetMetadataInput): void

nurbsCurve(controlPoints: Vec3[], opts?: {
    degree?: number;
    weights?: number[];
    knots?: number[];
    closed?: boolean;
}): Curve3D

nurbsPatchFamily(opts: {
    controls: Vec3[][];
    weights?: number[][];
    degree: {
        u: number;
        v: number;
    };
    knots?: {
        u: number[];
        v: number[];
    };
    periodic?: {
        u: boolean;
        v: boolean;
    };
    split: {
        direction: 'u' | 'v';
        knot?: number;
    };
    extrusion: Vec3;
    tolerance?: number;
}): Shape

nurbsSurface(opts: {
    controls: Vec3[][];
    weights?: number[][];
    degree: {
        u: number;
        v: number;
    };
    knots?: {
        u: number[];
        v: number[];
    };
    periodic?: {
        u: boolean;
        v: boolean;
    };
}): SurfaceProxy

param(name: string, defaultValue: number, meta?: ParamMetadata): ParamRef<number>
param(name: string, defaultValue: boolean, meta?: ParamMetadata): ParamRef<boolean>
param<C extends string>(name: string, defaultValue: C, meta: ParamMetadata & {
    choices: readonly C[];
}): TypedParamRef<C>
param(name: string, defaultValue: `#${string}`, meta?: ParamMetadata): TypedParamRef<`#${string}`>
param(name: string, defaultValue: string, meta?: ParamMetadata): TypedParamRef<string>

params<R extends Record<string, number | boolean>>(decl: R): {
    [K in keyof R]: ParamRef<R[K]>;
}

path(): PathBuilder

planeBlendSurface(railA: Curve3D, railB: Curve3D, opts: {
    normalA: Vec3;
    normalB: Vec3;
    handleLengthMm?: number;
}): SurfaceProxy

planetaryToothCompatibility(opts: PlanetaryToothCompatibilityOpts): void

presets(presets: AssetPresets): void

prismFront(points: readonly PolygonPoint[], x0: number, x1: number): Shape

prismPlan(points: readonly PolygonPoint[], z0: number, z1: number): Shape

prismSide(points: readonly PolygonPoint[], halfY?: number): Shape

prismSideY(points: readonly PolygonPoint[], y0: number, y1: number): Shape

referenceImage(path: string, opts: {
    plane: PlaneSpec;
    anchor?: 'origin' | [
        number,
        number,
        number
    ];
    scale?: ReferenceImageScale;
    opacity?: number;
    flipU?: boolean;
    flipV?: boolean;
}): ReferenceImageHandle

require(name: string, predicate: RequirementPredicate): void

ringGear(opts: InternalSpurGearOptions): Shape

select<T>(items: Iterable<T>): ShapeList<T>

selectEdge(shape: Shape, query: EdgeQuery): Promise<EdgeSegment>

selectEdges(shape: Shape, query?: EdgeQuery): Promise<ShapeList<EdgeSegment>>

setCameraDistance(distance: number): CameraTargetHandle

setCameraTarget(x: number, y: number, z: number): CameraTargetHandle

setRenderEnvironment(spec: RenderEnvironmentSpec): RenderEnvironmentHandle

sew(surfaces: SurfaceProxy[], opts?: {
    tolerance?: number;
    requireClosed?: boolean;
    continuity?: 'G0' | 'G1' | 'G2' | 'G3' | 'G4';
}): Shape

sheetMetal(profile: Sketch, opts: SheetMetalOpts): Shape

sphere(r: Editable<number>, opts?: FaceLabelOpts): Shape

spline3d(points: Vec3[], opts?: {
    tension?: number;
    closed?: boolean;
}): Curve3D

spring(opts: SpringOptions): Shape

spurGear(opts: SpurGearOptions): Shape

surfaceFromBoundary(curves: [
    Curve3D,
    Curve3D,
    Curve3D,
    Curve3D
], opts?: {
    continuity?: 'C0' | 'C1' | 'C2' | ('C0' | 'C1' | 'C2')[];
    sampling?: number;
}): SurfaceProxy

surfaceFromCurves(sections: Sketch[]): SurfaceProxy

surfaceIntersection(a: Shape | SurfaceProxy, b: Shape | SurfaceProxy): Promise<Curve3D[]>

threadedRod(opts: ThreadedRodOptions): Shape

torus(majorR: number, minorR: number, segments?: number): Shape

tube(name: string, opts: TubeOptions): Shape

tubeSpec(spec: TubeSpec): {
    id: FeatureId;
    metadata: TubeSpecMetadata;
}

union(...shapes: Shape[]): Shape

variableSweep(spine: Curve3D | Sketch | Vec3[], sections: Array<{
    t: number;
    profile: Sketch;
}>, opts?: {
    closed?: boolean;
    continuity?: 'C0' | 'C1' | 'C2';
}): Shape

volume(selection: unknown): RequirementPredicate