From 099c48cd63e6d09545f1ae661008dba5d92d7143 Mon Sep 17 00:00:00 2001 From: Jess Frazelle Date: Wed, 19 Feb 2025 19:48:27 -0800 Subject: [PATCH] better docs on solids and sketches (#5428) * updates Signed-off-by: Jess Frazelle * fix docs; Signed-off-by: Jess Frazelle * updates Signed-off-by: Jess Frazelle * updates Signed-off-by: Jess Frazelle * updates Signed-off-by: Jess Frazelle * updates Signed-off-by: Jess Frazelle * updates Signed-off-by: Jess Frazelle * updates Signed-off-by: Jess Frazelle * updates Signed-off-by: Jess Frazelle * updates Signed-off-by: Jess Frazelle * parens Signed-off-by: Jess Frazelle * parens Signed-off-by: Jess Frazelle --------- Signed-off-by: Jess Frazelle --- docs/kcl/chamfer.md | 4 +- docs/kcl/fillet.md | 4 +- docs/kcl/helixRevolutions.md | 4 +- docs/kcl/hollow.md | 4 +- docs/kcl/loft.md | 2 +- docs/kcl/revolve.md | 2 +- docs/kcl/std.json | 1059 ++++++++++------- docs/kcl/sweep.md | 2 +- docs/kcl/types/NumericType.md | 2 + docs/kcl/types/Sketch.md | 34 + docs/kcl/types/SketchSet.md | 34 + docs/kcl/types/Solid.md | 42 +- docs/kcl/types/SolidSet.md | 38 +- docs/kcl/types/UnitAngle.md | 3 +- docs/kcl/types/UnitLen.md | 3 +- src/wasm-lib/kcl/src/docs/gen_std_tests.rs | 62 + .../kcl/src/docs/templates/function.hbs | 4 +- .../kcl/src/docs/templates/properties.hbs | 2 +- src/wasm-lib/kcl/src/execution/geometry.rs | 84 +- src/wasm-lib/kcl/src/execution/kcl_value.rs | 2 + 20 files changed, 957 insertions(+), 434 deletions(-) diff --git a/docs/kcl/chamfer.md b/docs/kcl/chamfer.md index a70f48316..0d31e7252 100644 --- a/docs/kcl/chamfer.md +++ b/docs/kcl/chamfer.md @@ -18,12 +18,12 @@ chamfer(data: ChamferData, solid: Solid, tag?: TagDeclarator) -> Solid | Name | Type | Description | Required | |----------|------|-------------|----------| | `data` | [`ChamferData`](/docs/kcl/types/ChamferData) | Data for chamfers. | Yes | -| `solid` | [`Solid`](/docs/kcl/types/Solid) | An solid is a collection of extrude surfaces. | Yes | +| `solid` | [`Solid`](/docs/kcl/types/Solid) | A solid is a collection of extrude surfaces. | Yes | | `tag` | [`TagDeclarator`](/docs/kcl/types#tag-declaration) | | No | ### Returns -[`Solid`](/docs/kcl/types/Solid) - An solid is a collection of extrude surfaces. +[`Solid`](/docs/kcl/types/Solid) - A solid is a collection of extrude surfaces. ### Examples diff --git a/docs/kcl/fillet.md b/docs/kcl/fillet.md index 48890e5ad..4a89355ec 100644 --- a/docs/kcl/fillet.md +++ b/docs/kcl/fillet.md @@ -18,12 +18,12 @@ fillet(data: FilletData, solid: Solid, tag?: TagDeclarator) -> Solid | Name | Type | Description | Required | |----------|------|-------------|----------| | `data` | [`FilletData`](/docs/kcl/types/FilletData) | Data for fillets. | Yes | -| `solid` | [`Solid`](/docs/kcl/types/Solid) | An solid is a collection of extrude surfaces. | Yes | +| `solid` | [`Solid`](/docs/kcl/types/Solid) | A solid is a collection of extrude surfaces. | Yes | | `tag` | [`TagDeclarator`](/docs/kcl/types#tag-declaration) | | No | ### Returns -[`Solid`](/docs/kcl/types/Solid) - An solid is a collection of extrude surfaces. +[`Solid`](/docs/kcl/types/Solid) - A solid is a collection of extrude surfaces. ### Examples diff --git a/docs/kcl/helixRevolutions.md b/docs/kcl/helixRevolutions.md index 8335a09ab..4a7dd8b50 100644 --- a/docs/kcl/helixRevolutions.md +++ b/docs/kcl/helixRevolutions.md @@ -18,11 +18,11 @@ helixRevolutions(data: HelixRevolutionsData, solid: Solid) -> Solid | Name | Type | Description | Required | |----------|------|-------------|----------| | `data` | [`HelixRevolutionsData`](/docs/kcl/types/HelixRevolutionsData) | Data for helix revolutions. | Yes | -| `solid` | [`Solid`](/docs/kcl/types/Solid) | An solid is a collection of extrude surfaces. | Yes | +| `solid` | [`Solid`](/docs/kcl/types/Solid) | A solid is a collection of extrude surfaces. | Yes | ### Returns -[`Solid`](/docs/kcl/types/Solid) - An solid is a collection of extrude surfaces. +[`Solid`](/docs/kcl/types/Solid) - A solid is a collection of extrude surfaces. ### Examples diff --git a/docs/kcl/hollow.md b/docs/kcl/hollow.md index a9d73e41a..1746df2d5 100644 --- a/docs/kcl/hollow.md +++ b/docs/kcl/hollow.md @@ -18,11 +18,11 @@ hollow(thickness: number, solid: Solid) -> Solid | Name | Type | Description | Required | |----------|------|-------------|----------| | `thickness` | `number` | | Yes | -| `solid` | [`Solid`](/docs/kcl/types/Solid) | An solid is a collection of extrude surfaces. | Yes | +| `solid` | [`Solid`](/docs/kcl/types/Solid) | A solid is a collection of extrude surfaces. | Yes | ### Returns -[`Solid`](/docs/kcl/types/Solid) - An solid is a collection of extrude surfaces. +[`Solid`](/docs/kcl/types/Solid) - A solid is a collection of extrude surfaces. ### Examples diff --git a/docs/kcl/loft.md b/docs/kcl/loft.md index 523183665..6f2253ab5 100644 --- a/docs/kcl/loft.md +++ b/docs/kcl/loft.md @@ -25,7 +25,7 @@ loft(sketches: [Sketch], v_degree: NonZeroU32, bez_approximate_rational: bool, b ### Returns -[`Solid`](/docs/kcl/types/Solid) - An solid is a collection of extrude surfaces. +[`Solid`](/docs/kcl/types/Solid) - A solid is a collection of extrude surfaces. ### Examples diff --git a/docs/kcl/revolve.md b/docs/kcl/revolve.md index 0871c92f0..2e93df0f0 100644 --- a/docs/kcl/revolve.md +++ b/docs/kcl/revolve.md @@ -24,7 +24,7 @@ revolve(data: RevolveData, sketch: Sketch) -> Solid ### Returns -[`Solid`](/docs/kcl/types/Solid) - An solid is a collection of extrude surfaces. +[`Solid`](/docs/kcl/types/Solid) - A solid is a collection of extrude surfaces. ### Examples diff --git a/docs/kcl/std.json b/docs/kcl/std.json index 7fde28694..020b392ce 100644 --- a/docs/kcl/std.json +++ b/docs/kcl/std.json @@ -823,6 +823,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -1895,6 +1896,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -2262,7 +2264,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -3036,6 +3038,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -3606,7 +3609,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -3683,7 +3686,7 @@ } }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -4684,6 +4687,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -5756,6 +5760,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -6123,7 +6128,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -6897,6 +6902,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -7467,7 +7473,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -7544,7 +7550,7 @@ } }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -7862,7 +7868,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -8598,6 +8604,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -8983,7 +8990,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -9245,7 +9252,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -10201,6 +10208,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -10586,7 +10594,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -10848,7 +10856,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -11133,7 +11141,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -11869,6 +11877,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -12254,7 +12263,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -12516,7 +12525,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -12858,7 +12867,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -13594,6 +13603,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -13979,7 +13989,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -14241,7 +14251,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -15197,6 +15207,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -15582,7 +15593,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -15844,7 +15855,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -16129,7 +16140,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -16865,6 +16876,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -17250,7 +17262,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -17512,7 +17524,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -17854,7 +17866,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -18590,6 +18602,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -18975,7 +18988,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -19237,7 +19250,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -20193,6 +20206,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -20578,7 +20592,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -20840,7 +20854,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -21125,7 +21139,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -21861,6 +21875,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -22246,7 +22261,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -22508,7 +22523,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -23562,6 +23577,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -23929,7 +23945,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -24729,6 +24745,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -25299,7 +25316,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -25376,7 +25393,7 @@ } }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -26332,6 +26349,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -26902,7 +26920,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -26979,7 +26997,7 @@ } }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -27200,7 +27218,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -27936,6 +27954,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -28321,7 +28340,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -28583,7 +28602,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -28910,7 +28929,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -29646,6 +29665,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -30031,7 +30051,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -30293,7 +30313,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -31249,6 +31269,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -31634,7 +31655,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -31896,7 +31917,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -32181,7 +32202,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -32917,6 +32938,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -33302,7 +33324,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -33564,7 +33586,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -33891,7 +33913,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -34627,6 +34649,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -35012,7 +35035,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -35274,7 +35297,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -36230,6 +36253,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -36615,7 +36639,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -36877,7 +36901,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -37162,7 +37186,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -37898,6 +37922,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -38283,7 +38308,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -38545,7 +38570,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -38846,7 +38871,7 @@ "description": "A solid or a group of solids.", "oneOf": [ { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -39184,7 +39209,7 @@ "minItems": 3 }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -39920,6 +39945,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -40258,7 +40284,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -40783,7 +40809,7 @@ "minItems": 3 }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -41519,6 +41545,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -41857,7 +41884,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -42384,7 +42411,7 @@ "minItems": 3 }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -43120,6 +43147,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -43458,7 +43486,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -43984,7 +44012,7 @@ "minItems": 3 }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -44720,6 +44748,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -45058,7 +45087,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -45351,7 +45380,7 @@ "description": "A solid or a group of solids.", "oneOf": [ { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -45689,7 +45718,7 @@ "minItems": 3 }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -46425,6 +46454,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -46763,7 +46793,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -47153,7 +47183,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -47889,6 +47919,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -48274,7 +48305,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -48536,7 +48567,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -49492,6 +49523,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -49877,7 +49909,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -50139,7 +50171,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -50424,7 +50456,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -51160,6 +51192,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -51545,7 +51578,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -51807,7 +51840,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -52144,7 +52177,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -52880,6 +52913,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -53265,7 +53299,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -53527,7 +53561,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -54483,6 +54517,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -54868,7 +54903,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -55130,7 +55165,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -55415,7 +55450,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -56151,6 +56186,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -56536,7 +56572,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -56798,7 +56834,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -57668,7 +57704,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -58404,6 +58440,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -58789,7 +58826,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -59051,7 +59088,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -60007,6 +60044,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -60392,7 +60430,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -60654,7 +60692,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -60939,7 +60977,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -61675,6 +61713,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -62060,7 +62099,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -62322,7 +62361,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -63429,6 +63468,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -63796,7 +63836,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Solid", - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -64618,6 +64658,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -64978,7 +65019,7 @@ "format": "uuid" }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -65261,7 +65302,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -66239,6 +66280,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -66599,7 +66641,7 @@ "format": "uuid" }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -66882,7 +66924,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -67107,7 +67149,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Solid", - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -67416,7 +67458,7 @@ "minItems": 3 }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -68152,6 +68194,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -68490,7 +68533,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -69052,6 +69095,7 @@ } }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -69168,7 +69212,7 @@ "minItems": 3 }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -69462,7 +69506,7 @@ } }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -70655,6 +70699,7 @@ } }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -70771,7 +70816,7 @@ "minItems": 3 }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -71065,7 +71110,7 @@ } }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -72036,7 +72081,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -72772,6 +72817,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -73157,7 +73203,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -73419,7 +73465,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -74000,6 +74046,7 @@ } }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -74116,7 +74163,7 @@ "minItems": 3 }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -74410,7 +74457,7 @@ } }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -75604,6 +75651,7 @@ } }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -75720,7 +75768,7 @@ "minItems": 3 }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -76014,7 +76062,7 @@ } }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -76986,7 +77034,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -77722,6 +77770,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -78107,7 +78156,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -78369,7 +78418,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -78667,7 +78716,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -79403,6 +79452,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -79788,7 +79838,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -80050,7 +80100,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -81007,6 +81057,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -81392,7 +81443,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -81654,7 +81705,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -81940,7 +81991,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -82676,6 +82727,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -83061,7 +83113,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -83323,7 +83375,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -83723,7 +83775,7 @@ "description": "A sketch or a group of sketches.", "oneOf": [ { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -84488,6 +84540,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -84873,7 +84926,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -85135,7 +85188,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -86088,6 +86141,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -86473,7 +86527,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -86735,7 +86789,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -87025,7 +87079,7 @@ "description": "A solid or a group of solids.", "oneOf": [ { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -87363,7 +87417,7 @@ "minItems": 3 }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -88099,6 +88153,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -88437,7 +88492,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -89514,6 +89569,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -89881,7 +89937,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Solid", - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -90703,6 +90759,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -91063,7 +91120,7 @@ "format": "uuid" }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -91346,7 +91403,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -92324,6 +92381,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -92684,7 +92742,7 @@ "format": "uuid" }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -92967,7 +93025,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -93192,7 +93250,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Solid", - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -93501,7 +93559,7 @@ "minItems": 3 }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -94237,6 +94295,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -94575,7 +94634,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -95675,6 +95734,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -96796,6 +96856,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -97917,6 +97978,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -99217,6 +99279,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -100420,6 +100483,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -100844,6 +100908,7 @@ "format": "uuid" }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -101026,7 +101091,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Solid", - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -101335,7 +101400,7 @@ "minItems": 3 }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -102071,6 +102136,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -102409,7 +102475,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -102699,7 +102765,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Solid", - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -103008,7 +103074,7 @@ "minItems": 3 }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -103744,6 +103810,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -104082,7 +104149,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -104387,7 +104454,7 @@ "description": "A sketch or a group of sketches.", "oneOf": [ { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -105152,6 +105219,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -105537,7 +105605,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -105799,7 +105867,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -106084,7 +106152,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -106820,6 +106888,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -107205,7 +107274,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -107467,7 +107536,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -107753,7 +107822,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -108489,6 +108558,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -108874,7 +108944,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -109136,7 +109206,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -109448,7 +109518,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Solid", - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -109757,7 +109827,7 @@ "minItems": 3 }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -110493,6 +110563,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -110831,7 +110902,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -111121,7 +111192,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Solid", - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -111430,7 +111501,7 @@ "minItems": 3 }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -112166,6 +112237,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -112504,7 +112576,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -113296,7 +113368,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -114032,6 +114104,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -114417,7 +114490,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -114679,7 +114752,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -114992,7 +115065,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -115728,6 +115801,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -116113,7 +116187,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -116375,7 +116449,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -116853,7 +116927,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -117589,6 +117663,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -117974,7 +118049,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -118236,7 +118311,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -119195,6 +119270,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -119580,7 +119656,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -119842,7 +119918,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -120800,6 +120876,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -121185,7 +121262,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -121447,7 +121524,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -122404,6 +122481,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -122789,7 +122867,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -123051,7 +123129,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -123337,7 +123415,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -124073,6 +124151,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -124458,7 +124537,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -124720,7 +124799,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -125066,7 +125145,7 @@ }, "definitions": { "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -125802,6 +125881,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -126187,7 +126267,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -126667,7 +126747,7 @@ "minimum": 1.0, "definitions": { "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -127403,6 +127483,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -127788,7 +127869,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -128266,7 +128347,7 @@ "type": "boolean", "definitions": { "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -129002,6 +129083,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -129387,7 +129469,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -129868,7 +129950,7 @@ "nullable": true, "definitions": { "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -130604,6 +130686,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -130989,7 +131072,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -131468,7 +131551,7 @@ "nullable": true, "definitions": { "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -132204,6 +132287,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -132589,7 +132673,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -133064,7 +133148,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Solid", - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -133373,7 +133457,7 @@ "minItems": 3 }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -134109,6 +134193,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -134447,7 +134532,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -135478,6 +135563,7 @@ } }, { + "description": "A unit of length.", "type": "object", "oneOf": [ { @@ -135578,6 +135664,7 @@ } }, { + "description": "A unit of angle.", "type": "object", "oneOf": [ { @@ -135687,6 +135774,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -135775,6 +135863,7 @@ ] }, "UnitAngle": { + "description": "A unit of angle.", "oneOf": [ { "type": "object", @@ -136943,7 +137032,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -137020,7 +137109,7 @@ } }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -138088,6 +138177,7 @@ } }, { + "description": "A unit of length.", "type": "object", "oneOf": [ { @@ -138188,6 +138278,7 @@ } }, { + "description": "A unit of angle.", "type": "object", "oneOf": [ { @@ -138297,6 +138388,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -138385,6 +138477,7 @@ ] }, "UnitAngle": { + "description": "A unit of angle.", "oneOf": [ { "type": "object", @@ -139553,7 +139646,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -139630,7 +139723,7 @@ } }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -140702,6 +140795,7 @@ } }, { + "description": "A unit of length.", "type": "object", "oneOf": [ { @@ -140802,6 +140896,7 @@ } }, { + "description": "A unit of angle.", "type": "object", "oneOf": [ { @@ -140911,6 +141006,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -140999,6 +141095,7 @@ ] }, "UnitAngle": { + "description": "A unit of angle.", "oneOf": [ { "type": "object", @@ -142167,7 +142264,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -142244,7 +142341,7 @@ } }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -143713,6 +143810,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -144083,7 +144181,7 @@ "description": "A sketch or a group of sketches.", "oneOf": [ { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -145022,6 +145120,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -145592,7 +145691,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -145669,7 +145768,7 @@ } }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -145897,7 +145996,7 @@ }, "definitions": { "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -146633,6 +146732,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -147018,7 +147118,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -147829,6 +147929,7 @@ } }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -147976,7 +148077,7 @@ "description": "A sketch or a group of sketches.", "oneOf": [ { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -148741,6 +148842,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -149126,7 +149228,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -149388,7 +149490,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -150342,6 +150444,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -150727,7 +150830,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -150989,7 +151092,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -151947,6 +152050,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -152332,7 +152436,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -152594,7 +152698,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -153547,6 +153651,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -153932,7 +154037,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -154194,7 +154299,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -155146,6 +155251,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -155531,7 +155637,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -155793,7 +155899,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -156746,6 +156852,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -157131,7 +157238,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -157393,7 +157500,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -157685,7 +157792,7 @@ }, "definitions": { "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -158421,6 +158528,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -158806,7 +158914,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -159296,7 +159404,7 @@ "description": "A solid or a group of solids.", "oneOf": [ { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -159634,7 +159742,7 @@ "minItems": 3 }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -160370,6 +160478,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -160708,7 +160817,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -161235,7 +161344,7 @@ "minItems": 3 }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -161971,6 +162080,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -162309,7 +162419,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -162840,7 +162950,7 @@ "minItems": 3 }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -163576,6 +163686,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -163914,7 +164025,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -164445,7 +164556,7 @@ "minItems": 3 }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -165181,6 +165292,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -165519,7 +165631,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -166045,7 +166157,7 @@ "minItems": 3 }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -166781,6 +166893,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -167119,7 +167232,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -167644,7 +167757,7 @@ "minItems": 3 }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -168380,6 +168493,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -168718,7 +168832,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -169244,7 +169358,7 @@ "minItems": 3 }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -169980,6 +170094,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -170318,7 +170433,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -170614,7 +170729,7 @@ }, "definitions": { "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -170923,7 +171038,7 @@ "minItems": 3 }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -171659,6 +171774,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -172225,7 +172341,7 @@ "description": "A sketch or a group of sketches.", "oneOf": [ { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -172990,6 +173106,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -173375,7 +173492,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -173637,7 +173754,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -174591,6 +174708,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -174976,7 +175094,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -175238,7 +175356,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -176191,6 +176309,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -176576,7 +176695,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -176838,7 +176957,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -177796,6 +177915,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -178181,7 +178301,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -178443,7 +178563,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -179396,6 +179516,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -179781,7 +179902,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -180043,7 +180164,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -180335,7 +180456,7 @@ }, "definitions": { "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -181071,6 +181192,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -181456,7 +181578,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -181946,7 +182068,7 @@ "description": "A solid or a group of solids.", "oneOf": [ { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -182284,7 +182406,7 @@ "minItems": 3 }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -183020,6 +183142,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -183358,7 +183481,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -183885,7 +184008,7 @@ "minItems": 3 }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -184621,6 +184744,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -184959,7 +185083,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -185485,7 +185609,7 @@ "minItems": 3 }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -186221,6 +186345,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -186559,7 +186684,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -187090,7 +187215,7 @@ "minItems": 3 }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -187826,6 +187951,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -188164,7 +188290,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -188690,7 +188816,7 @@ "minItems": 3 }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -189426,6 +189552,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -189764,7 +189891,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -190060,7 +190187,7 @@ }, "definitions": { "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -190369,7 +190496,7 @@ "minItems": 3 }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -191105,6 +191232,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -191671,7 +191799,7 @@ "description": "A solid or a group of solids.", "oneOf": [ { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -192009,7 +192137,7 @@ "minItems": 3 }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -192745,6 +192873,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -193083,7 +193212,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -193610,7 +193739,7 @@ "minItems": 3 }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -194346,6 +194475,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -194684,7 +194814,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -195209,7 +195339,7 @@ "minItems": 3 }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -195945,6 +196075,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -196283,7 +196414,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -196809,7 +196940,7 @@ "minItems": 3 }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -197545,6 +197676,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -197883,7 +198015,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -198179,7 +198311,7 @@ }, "definitions": { "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -198488,7 +198620,7 @@ "minItems": 3 }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -199224,6 +199356,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -199795,7 +199928,7 @@ "description": "A sketch or a group of sketches.", "oneOf": [ { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -200560,6 +200693,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -200945,7 +201079,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -201207,7 +201341,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -202161,6 +202295,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -202546,7 +202681,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -202808,7 +202943,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -203760,6 +203895,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -204145,7 +204281,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -204407,7 +204543,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -205360,6 +205496,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -205745,7 +205882,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -206007,7 +206144,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -206299,7 +206436,7 @@ }, "definitions": { "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -207035,6 +207172,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -207420,7 +207558,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -207974,6 +208112,7 @@ } }, { + "description": "A unit of length.", "type": "object", "oneOf": [ { @@ -208074,6 +208213,7 @@ } }, { + "description": "A unit of angle.", "type": "object", "oneOf": [ { @@ -208183,6 +208323,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -208271,6 +208412,7 @@ ] }, "UnitAngle": { + "description": "A unit of angle.", "oneOf": [ { "type": "object", @@ -208617,6 +208759,7 @@ } }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -208733,7 +208876,7 @@ "minItems": 3 }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -209027,7 +209170,7 @@ } }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -210220,6 +210363,7 @@ } }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -210336,7 +210480,7 @@ "minItems": 3 }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -210630,7 +210774,7 @@ } }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -211601,7 +211745,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -212337,6 +212481,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -212722,7 +212867,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -212984,7 +213129,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -213843,6 +213988,7 @@ } }, { + "description": "A unit of length.", "type": "object", "oneOf": [ { @@ -213943,6 +214089,7 @@ } }, { + "description": "A unit of angle.", "type": "object", "oneOf": [ { @@ -214052,6 +214199,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -214140,6 +214288,7 @@ ] }, "UnitAngle": { + "description": "A unit of angle.", "oneOf": [ { "type": "object", @@ -215308,7 +215457,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -215385,7 +215534,7 @@ } }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -216452,6 +216601,7 @@ } }, { + "description": "A unit of length.", "type": "object", "oneOf": [ { @@ -216552,6 +216702,7 @@ } }, { + "description": "A unit of angle.", "type": "object", "oneOf": [ { @@ -216661,6 +216812,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -216749,6 +216901,7 @@ ] }, "UnitAngle": { + "description": "A unit of angle.", "oneOf": [ { "type": "object", @@ -218424,7 +218577,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -218501,7 +218654,7 @@ } }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -219080,7 +219233,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -219816,6 +219969,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -220201,7 +220355,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -220463,7 +220617,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -220780,7 +220934,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -221516,6 +221670,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -221901,7 +222056,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -222163,7 +222318,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -222475,7 +222630,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -223211,6 +223366,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -223596,7 +223752,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -223858,7 +224014,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -224730,6 +224886,7 @@ } }, { + "description": "A unit of length.", "type": "object", "oneOf": [ { @@ -224830,6 +224987,7 @@ } }, { + "description": "A unit of angle.", "type": "object", "oneOf": [ { @@ -224939,6 +225097,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -225027,6 +225186,7 @@ ] }, "UnitAngle": { + "description": "A unit of angle.", "oneOf": [ { "type": "object", @@ -226195,7 +226355,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -226272,7 +226432,7 @@ } }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -227844,6 +228004,7 @@ } }, { + "description": "A unit of length.", "type": "object", "oneOf": [ { @@ -227944,6 +228105,7 @@ } }, { + "description": "A unit of angle.", "type": "object", "oneOf": [ { @@ -228053,6 +228215,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -228141,6 +228304,7 @@ ] }, "UnitAngle": { + "description": "A unit of angle.", "oneOf": [ { "type": "object", @@ -229309,7 +229473,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -229386,7 +229550,7 @@ } }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -230452,6 +230616,7 @@ } }, { + "description": "A unit of length.", "type": "object", "oneOf": [ { @@ -230552,6 +230717,7 @@ } }, { + "description": "A unit of angle.", "type": "object", "oneOf": [ { @@ -230661,6 +230827,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -230749,6 +230916,7 @@ ] }, "UnitAngle": { + "description": "A unit of angle.", "oneOf": [ { "type": "object", @@ -232424,7 +232592,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -232501,7 +232669,7 @@ } }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -233585,6 +233753,7 @@ } }, { + "description": "A unit of length.", "type": "object", "oneOf": [ { @@ -233685,6 +233854,7 @@ } }, { + "description": "A unit of angle.", "type": "object", "oneOf": [ { @@ -233794,6 +233964,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -233882,6 +234053,7 @@ ] }, "UnitAngle": { + "description": "A unit of angle.", "oneOf": [ { "type": "object", @@ -235050,7 +235222,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -235127,7 +235299,7 @@ } }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -236699,6 +236871,7 @@ } }, { + "description": "A unit of length.", "type": "object", "oneOf": [ { @@ -236799,6 +236972,7 @@ } }, { + "description": "A unit of angle.", "type": "object", "oneOf": [ { @@ -236908,6 +237082,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -236996,6 +237171,7 @@ ] }, "UnitAngle": { + "description": "A unit of angle.", "oneOf": [ { "type": "object", @@ -238164,7 +238340,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -238241,7 +238417,7 @@ } }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -239309,6 +239485,7 @@ } }, { + "description": "A unit of length.", "type": "object", "oneOf": [ { @@ -239409,6 +239586,7 @@ } }, { + "description": "A unit of angle.", "type": "object", "oneOf": [ { @@ -239518,6 +239696,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -239606,6 +239785,7 @@ ] }, "UnitAngle": { + "description": "A unit of angle.", "oneOf": [ { "type": "object", @@ -240774,7 +240954,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -240851,7 +241031,7 @@ } }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -241917,6 +242097,7 @@ } }, { + "description": "A unit of length.", "type": "object", "oneOf": [ { @@ -242017,6 +242198,7 @@ } }, { + "description": "A unit of angle.", "type": "object", "oneOf": [ { @@ -242126,6 +242308,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -242214,6 +242397,7 @@ ] }, "UnitAngle": { + "description": "A unit of angle.", "oneOf": [ { "type": "object", @@ -243889,7 +244073,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -243966,7 +244150,7 @@ } }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -245419,6 +245603,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -245786,7 +245971,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -246696,6 +246881,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -247266,7 +247452,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -247343,7 +247529,7 @@ } }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -247565,7 +247751,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Solid", - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -247874,7 +248060,7 @@ "minItems": 3 }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -248610,6 +248796,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -248948,7 +249135,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -250026,6 +250213,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -251148,6 +251336,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -252275,6 +252464,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -253397,6 +253587,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -254519,6 +254710,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -255641,6 +255833,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -256768,6 +256961,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -257890,6 +258084,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -258288,7 +258483,7 @@ "description": "A solid or a group of solids.", "oneOf": [ { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -258626,7 +258821,7 @@ "minItems": 3 }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -259362,6 +259557,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -259700,7 +259896,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -260226,7 +260422,7 @@ "minItems": 3 }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -260962,6 +261158,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -261300,7 +261497,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -261828,7 +262025,7 @@ "minItems": 3 }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -262564,6 +262761,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -262902,7 +263100,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -263230,7 +263428,7 @@ "description": "A solid or a group of solids.", "oneOf": [ { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -263568,7 +263766,7 @@ "minItems": 3 }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -264304,6 +264502,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -264642,7 +264841,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -265266,6 +265465,7 @@ } }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -265382,7 +265582,7 @@ "minItems": 3 }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -265676,7 +265876,7 @@ } }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -266869,6 +267069,7 @@ } }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -266985,7 +267186,7 @@ "minItems": 3 }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -267279,7 +267480,7 @@ } }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -268418,7 +268619,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -269154,6 +269355,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -269539,7 +269741,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -269801,7 +270003,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -270120,7 +270322,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -270856,6 +271058,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -271241,7 +271444,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -271503,7 +271706,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -272037,6 +272240,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -272153,7 +272357,7 @@ "minItems": 3 }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -272447,7 +272651,7 @@ } }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -273814,6 +274018,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -273930,7 +274135,7 @@ "minItems": 3 }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -274224,7 +274429,7 @@ } }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -275611,6 +275816,7 @@ } }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -275727,7 +275933,7 @@ "minItems": 3 }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -276021,7 +276227,7 @@ } }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -277176,7 +277382,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -277912,6 +278118,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -278297,7 +278504,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -278559,7 +278766,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -279519,6 +279726,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -279904,7 +280112,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -280166,7 +280374,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -281170,6 +281378,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -281555,7 +281764,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -281817,7 +282026,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -282821,6 +283030,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -283206,7 +283416,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -283468,7 +283678,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -283805,7 +284015,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Solid", - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -284114,7 +284324,7 @@ "minItems": 3 }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -284850,6 +285060,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -285188,7 +285399,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -286260,6 +286471,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -286692,7 +286904,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -287428,6 +287640,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -287813,7 +288026,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -288075,7 +288288,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -289031,6 +289244,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -289416,7 +289630,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -289678,7 +289892,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -289963,7 +290177,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -290699,6 +290913,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -291084,7 +291299,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -291346,7 +291561,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -291662,7 +291877,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -292398,6 +292613,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -292783,7 +292999,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -293045,7 +293261,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -294001,6 +294217,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -294386,7 +294603,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -294648,7 +294865,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -294933,7 +295150,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -295669,6 +295886,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -296054,7 +296272,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -296316,7 +296534,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -296632,7 +296850,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -297368,6 +297586,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -297753,7 +297972,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -298015,7 +298234,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -298971,6 +299190,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -299356,7 +299576,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -299618,7 +299838,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -299903,7 +300123,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -300639,6 +300859,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -301024,7 +301245,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -301286,7 +301507,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -301709,7 +301930,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -302445,6 +302666,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -302830,7 +303052,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -303092,7 +303314,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -304048,6 +304270,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -304433,7 +304656,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -304695,7 +304918,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -304980,7 +305203,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -305716,6 +305939,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -306101,7 +306325,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -306363,7 +306587,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -306674,7 +306898,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -307410,6 +307634,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -307795,7 +308020,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -308057,7 +308282,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -309013,6 +309238,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -309398,7 +309624,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -309660,7 +309886,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -309945,7 +310171,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -310681,6 +310907,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -311066,7 +311293,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -311328,7 +311555,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -311639,7 +311866,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -312375,6 +312602,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -312760,7 +312988,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -313022,7 +313250,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -313978,6 +314206,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -314363,7 +314592,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -314625,7 +314854,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -314910,7 +315139,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -315646,6 +315875,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -316031,7 +316261,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -316293,7 +316523,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -316604,7 +316834,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -317340,6 +317570,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -317725,7 +317956,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -317987,7 +318218,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -318943,6 +319174,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -319328,7 +319560,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -319590,7 +319822,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -319875,7 +320107,7 @@ "schema": { "$schema": "https://spec.openapis.org/oas/3.0/schema/2019-04-02#/definitions/Schema", "title": "Sketch", - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", @@ -320611,6 +320843,7 @@ ] }, "UnitLen": { + "description": "A unit of length.", "oneOf": [ { "type": "object", @@ -320996,7 +321229,7 @@ } }, "Solid": { - "description": "An solid is a collection of extrude surfaces.", + "description": "A solid is a collection of extrude surfaces.\n\nWhen you define a solid to a variable like:\n\n```kcl myPart = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) ```\n\nThe `myPart` variable will be an executed `Solid` object. Executed being past tense, because the engine has already executed the commands to create the solid.\n\nThe previous solid commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the solid any time you call it, you can use a function.\n\n```kcl fn createPart() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() |> extrude(length = 6) } ```\n\nNow, every time you call `createPart()`, the commands will be executed and a new solid will be created.\n\nWhen you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again.\n\nYou can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated.", "type": "object", "required": [ "__meta", @@ -321258,7 +321491,7 @@ ] }, "Sketch": { - "description": "A sketch is a collection of paths.", + "description": "A sketch is a collection of paths.\n\nWhen you define a sketch to a variable like:\n\n```kcl mySketch = startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() ```\n\nThe `mySketch` variable will be an executed `Sketch` object. Executed being past tense, because the engine has already executed the commands to create the sketch.\n\nThe previous sketch commands will never be executed again, in this case.\n\nIf you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.\n\n```kcl fn createSketch() { return startSketchOn('XY') |> startProfileAt([-12, 12], %) |> line(end = [24, 0]) |> line(end = [0, -24]) |> line(end = [-24, 0]) |> close() } ```\n\nNow, every time you call `createSketch()`, the commands will be executed and a new sketch will be created.\n\nWhen you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again.\n\nYou can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated.", "type": "object", "required": [ "__meta", diff --git a/docs/kcl/sweep.md b/docs/kcl/sweep.md index 4f5a1cd76..e61bbcdd4 100644 --- a/docs/kcl/sweep.md +++ b/docs/kcl/sweep.md @@ -24,7 +24,7 @@ sweep(sketch: Sketch, path: SweepPath, sectional?: bool, tolerance?: number) -> ### Returns -[`Solid`](/docs/kcl/types/Solid) - An solid is a collection of extrude surfaces. +[`Solid`](/docs/kcl/types/Solid) - A solid is a collection of extrude surfaces. ### Examples diff --git a/docs/kcl/types/NumericType.md b/docs/kcl/types/NumericType.md index 3e8386e1e..fd6767a4f 100644 --- a/docs/kcl/types/NumericType.md +++ b/docs/kcl/types/NumericType.md @@ -33,6 +33,7 @@ layout: manual ---- +A unit of length. **Type:** `object` @@ -140,6 +141,7 @@ layout: manual ---- +A unit of angle. **Type:** `object` diff --git a/docs/kcl/types/Sketch.md b/docs/kcl/types/Sketch.md index 00d18082a..9c3efb9da 100644 --- a/docs/kcl/types/Sketch.md +++ b/docs/kcl/types/Sketch.md @@ -6,6 +6,40 @@ layout: manual A sketch is a collection of paths. +When you define a sketch to a variable like: + +```kcl +mySketch = startSketchOn('XY') + |> startProfileAt([-12, 12], %) + |> line(end = [24, 0]) + |> line(end = [0, -24]) + |> line(end = [-24, 0]) + |> close() +``` + +The `mySketch` variable will be an executed [`Sketch`](/docs/kcl/types/Sketch) object. Executed being past tense, because the engine has already executed the commands to create the sketch. + +The previous sketch commands will never be executed again, in this case. + +If you would like to encapsulate the commands to create the sketch any time you call it, you can use a function. + +```kcl +fn createSketch() { + return startSketchOn('XY') + |> startProfileAt([-12, 12], %) + |> line(end = [24, 0]) + |> line(end = [0, -24]) + |> line(end = [-24, 0]) + |> close() +} +``` + +Now, every time you call `createSketch()`, the commands will be executed and a new sketch will be created. + +When you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again. + +You can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated. + **Type:** `object` diff --git a/docs/kcl/types/SketchSet.md b/docs/kcl/types/SketchSet.md index 9cf3827ed..a7ab9a770 100644 --- a/docs/kcl/types/SketchSet.md +++ b/docs/kcl/types/SketchSet.md @@ -14,6 +14,40 @@ A sketch or a group of sketches. A sketch is a collection of paths. +When you define a sketch to a variable like: + +```kcl +mySketch = startSketchOn('XY') + |> startProfileAt([-12, 12], %) + |> line(end = [24, 0]) + |> line(end = [0, -24]) + |> line(end = [-24, 0]) + |> close() +``` + +The `mySketch` variable will be an executed [`Sketch`](/docs/kcl/types/Sketch) object. Executed being past tense, because the engine has already executed the commands to create the sketch. + +The previous sketch commands will never be executed again, in this case. + +If you would like to encapsulate the commands to create the sketch any time you call it, you can use a function. + +```kcl +fn createSketch() { + return startSketchOn('XY') + |> startProfileAt([-12, 12], %) + |> line(end = [24, 0]) + |> line(end = [0, -24]) + |> line(end = [-24, 0]) + |> close() +} +``` + +Now, every time you call `createSketch()`, the commands will be executed and a new sketch will be created. + +When you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed again. + +You can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and the sketch will be updated. + **Type:** `object` diff --git a/docs/kcl/types/Solid.md b/docs/kcl/types/Solid.md index 2b988c851..1218f8018 100644 --- a/docs/kcl/types/Solid.md +++ b/docs/kcl/types/Solid.md @@ -1,10 +1,46 @@ --- title: "Solid" -excerpt: "An solid is a collection of extrude surfaces." +excerpt: "A solid is a collection of extrude surfaces." layout: manual --- -An solid is a collection of extrude surfaces. +A solid is a collection of extrude surfaces. + +When you define a solid to a variable like: + +```kcl +myPart = startSketchOn('XY') + |> startProfileAt([-12, 12], %) + |> line(end = [24, 0]) + |> line(end = [0, -24]) + |> line(end = [-24, 0]) + |> close() + |> extrude(length = 6) +``` + +The `myPart` variable will be an executed [`Solid`](/docs/kcl/types/Solid) object. Executed being past tense, because the engine has already executed the commands to create the solid. + +The previous solid commands will never be executed again, in this case. + +If you would like to encapsulate the commands to create the solid any time you call it, you can use a function. + +```kcl +fn createPart() { + return startSketchOn('XY') + |> startProfileAt([-12, 12], %) + |> line(end = [24, 0]) + |> line(end = [0, -24]) + |> line(end = [-24, 0]) + |> close() + |> extrude(length = 6) +} +``` + +Now, every time you call `createPart()`, the commands will be executed and a new solid will be created. + +When you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again. + +You can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated. **Type:** `object` @@ -24,7 +60,7 @@ An solid is a collection of extrude surfaces. | `startCapId` |`string`| The id of the extrusion start cap | No | | `endCapId` |`string`| The id of the extrusion end cap | No | | `edgeCuts` |`[` [`EdgeCut`](/docs/kcl/types/EdgeCut) `]`| Chamfers or fillets on this solid. | No | -| `units` |[`UnitLen`](/docs/kcl/types/UnitLen)| An solid is a collection of extrude surfaces. | No | +| `units` |[`UnitLen`](/docs/kcl/types/UnitLen)| A solid is a collection of extrude surfaces. | No | | `__meta` |`[` [`Metadata`](/docs/kcl/types/Metadata) `]`| Metadata. | No | diff --git a/docs/kcl/types/SolidSet.md b/docs/kcl/types/SolidSet.md index 0ab3d01b1..433030dee 100644 --- a/docs/kcl/types/SolidSet.md +++ b/docs/kcl/types/SolidSet.md @@ -12,7 +12,43 @@ A solid or a group of solids. **This schema accepts exactly one of the following:** -An solid is a collection of extrude surfaces. +A solid is a collection of extrude surfaces. + +When you define a solid to a variable like: + +```kcl +myPart = startSketchOn('XY') + |> startProfileAt([-12, 12], %) + |> line(end = [24, 0]) + |> line(end = [0, -24]) + |> line(end = [-24, 0]) + |> close() + |> extrude(length = 6) +``` + +The `myPart` variable will be an executed [`Solid`](/docs/kcl/types/Solid) object. Executed being past tense, because the engine has already executed the commands to create the solid. + +The previous solid commands will never be executed again, in this case. + +If you would like to encapsulate the commands to create the solid any time you call it, you can use a function. + +```kcl +fn createPart() { + return startSketchOn('XY') + |> startProfileAt([-12, 12], %) + |> line(end = [24, 0]) + |> line(end = [0, -24]) + |> line(end = [-24, 0]) + |> close() + |> extrude(length = 6) +} +``` + +Now, every time you call `createPart()`, the commands will be executed and a new solid will be created. + +When you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning the executed solid to that variable. Meaning that the solid `myPart` will not be executed again. + +You can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. and the solid will be updated. **Type:** `object` diff --git a/docs/kcl/types/UnitAngle.md b/docs/kcl/types/UnitAngle.md index b825cab92..a9660e2cf 100644 --- a/docs/kcl/types/UnitAngle.md +++ b/docs/kcl/types/UnitAngle.md @@ -1,9 +1,10 @@ --- title: "UnitAngle" -excerpt: "" +excerpt: "A unit of angle." layout: manual --- +A unit of angle. diff --git a/docs/kcl/types/UnitLen.md b/docs/kcl/types/UnitLen.md index b7dc89f9e..747440241 100644 --- a/docs/kcl/types/UnitLen.md +++ b/docs/kcl/types/UnitLen.md @@ -1,9 +1,10 @@ --- title: "UnitLen" -excerpt: "" +excerpt: "A unit of length." layout: manual --- +A unit of length. diff --git a/src/wasm-lib/kcl/src/docs/gen_std_tests.rs b/src/wasm-lib/kcl/src/docs/gen_std_tests.rs index 48f2bc362..d0de7d538 100644 --- a/src/wasm-lib/kcl/src/docs/gen_std_tests.rs +++ b/src/wasm-lib/kcl/src/docs/gen_std_tests.rs @@ -95,6 +95,28 @@ fn init_handlebars() -> Result> { ), ); + hbs.register_helper( + "firstLine", + Box::new( + |h: &handlebars::Helper, + _: &handlebars::Handlebars, + _: &handlebars::Context, + _: &mut handlebars::RenderContext, + out: &mut dyn handlebars::Output| + -> handlebars::HelperResult { + // Get the first parameter passed to the helper + let param = h.param(0).and_then(|v| v.value().as_str()).unwrap_or(""); + + // Get the first line using lines() iterator + let first = param.lines().next().unwrap_or(""); + + // Write the result + out.write(first)?; + Ok(()) + }, + ), + ); + hbs.register_helper( "neq", Box::new( @@ -566,6 +588,10 @@ fn generate_type( })); } + // Cleanup the description. + let object = cleanup_type_description(&object) + .map_err(|e| anyhow::anyhow!("Failed to cleanup type description for type `{}`: {}", name, e))?; + let data = json!(schemars::schema::Schema::Object(object)); let mut output = hbs.render("type", &data)?; @@ -576,6 +602,39 @@ fn generate_type( Ok(()) } +fn cleanup_type_description(object: &schemars::schema::SchemaObject) -> Result { + let mut object = object.clone(); + if let Some(metadata) = object.metadata.as_mut() { + if let Some(description) = metadata.description.as_mut() { + // Find any ```kcl code blocks and format the code. + // Parse any code blocks from the doc string. + let mut code_blocks = Vec::new(); + let d = description.clone(); + for line in d.lines() { + if line.starts_with("```kcl") && line.ends_with("```") { + code_blocks.push(line); + } + } + + // Parse the kcl and recast it. + for code_block in &code_blocks { + let trimmed = code_block.trim_start_matches("```kcl").trim_end_matches("```"); + let program = crate::Program::parse_no_errs(trimmed)?; + + let options = crate::parsing::ast::types::FormatOptions { + insert_final_newline: false, + ..Default::default() + }; + let cleaned = program.ast.recast(&options, 0); + + *description = description.replace(code_block, &format!("```kcl\n{}\n```", cleaned)); + } + } + } + + Ok(object) +} + fn clean_function_name(name: &str) -> String { // Convert from camel case to snake case. let mut fn_name = name.to_case(convert_case::Case::Snake); @@ -733,6 +792,9 @@ fn recurse_and_create_references( } } + let obj = cleanup_type_description(&obj) + .map_err(|e| anyhow::anyhow!("Failed to cleanup type description for type `{}`: {}", name, e))?; + Ok(schemars::schema::Schema::Object(obj.clone())) } diff --git a/src/wasm-lib/kcl/src/docs/templates/function.hbs b/src/wasm-lib/kcl/src/docs/templates/function.hbs index 458254714..83d4fbdd9 100644 --- a/src/wasm-lib/kcl/src/docs/templates/function.hbs +++ b/src/wasm-lib/kcl/src/docs/templates/function.hbs @@ -31,14 +31,14 @@ layout: manual | Name | Type | Description | Required | |----------|------|-------------|----------| {{#each args}} -| `{{name}}` | `{{type_}}` | {{{description}}} | {{#if required}}Yes{{else}}No{{/if}} | +| `{{name}}` | `{{type_}}` | {{{firstLine description}}} | {{#if required}}Yes{{else}}No{{/if}} | {{/each}} {{/if}} {{#if return_value}} ### Returns -`{{return_value.type_}}` {{#if return_value.description}}- {{{return_value.description}}}{{/if}} +`{{return_value.type_}}` {{#if return_value.description}}- {{{firstLine return_value.description}}}{{/if}} {{/if}} diff --git a/src/wasm-lib/kcl/src/docs/templates/properties.hbs b/src/wasm-lib/kcl/src/docs/templates/properties.hbs index ff0c4df8a..283f68456 100644 --- a/src/wasm-lib/kcl/src/docs/templates/properties.hbs +++ b/src/wasm-lib/kcl/src/docs/templates/properties.hbs @@ -8,6 +8,6 @@ | Property | Type | Description | Required | |----------|------|-------------|----------| {{#each properties}} -| `{{@key}}` | {{~ > propertyType this ~}} | {{{this.description}}} | {{#if (lookup ../required @key)}}Yes{{else}}No{{/if}} | +| `{{@key}}` | {{~ > propertyType this ~}} | {{{firstLine this.description}}} | {{#if (lookup ../required @key)}}Yes{{else}}No{{/if}} | {{/each}} {{/if}} diff --git a/src/wasm-lib/kcl/src/execution/geometry.rs b/src/wasm-lib/kcl/src/execution/geometry.rs index ebe3dea01..24b149e69 100644 --- a/src/wasm-lib/kcl/src/execution/geometry.rs +++ b/src/wasm-lib/kcl/src/execution/geometry.rs @@ -408,6 +408,46 @@ pub enum PlaneType { } /// A sketch is a collection of paths. +/// +/// When you define a sketch to a variable like: +/// +/// ```kcl +/// mySketch = startSketchOn('XY') +/// |> startProfileAt([-12, 12], %) +/// |> line(end = [24, 0]) +/// |> line(end = [0, -24]) +/// |> line(end = [-24, 0]) +/// |> close() +/// ``` +/// +/// The `mySketch` variable will be an executed `Sketch` object. Executed being past +/// tense, because the engine has already executed the commands to create the sketch. +/// +/// The previous sketch commands will never be executed again, in this case. +/// +/// If you would like to encapsulate the commands to create the sketch any time you call it, +/// you can use a function. +/// +/// ```kcl +/// fn createSketch() { +/// return startSketchOn('XY') +/// |> startProfileAt([-12, 12], %) +/// |> line(end = [24, 0]) +/// |> line(end = [0, -24]) +/// |> line(end = [-24, 0]) +/// |> close() +/// } +/// ``` +/// +/// Now, every time you call `createSketch()`, the commands will be +/// executed and a new sketch will be created. +/// +/// When you assign the result of `createSketch()` to a variable (`mySketch = createSketch()`), you are assigning +/// the executed sketch to that variable. Meaning that the sketch `mySketch` will not be executed +/// again. +/// +/// You can still execute _new_ commands on the sketch like `extrude`, `revolve`, `loft`, etc. and +/// the sketch will be updated. #[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)] #[ts(export)] #[serde(tag = "type", rename_all = "camelCase")] @@ -538,7 +578,49 @@ impl Sketch { } } -/// An solid is a collection of extrude surfaces. +/// A solid is a collection of extrude surfaces. +/// +/// When you define a solid to a variable like: +/// +/// ```kcl +/// myPart = startSketchOn('XY') +/// |> startProfileAt([-12, 12], %) +/// |> line(end = [24, 0]) +/// |> line(end = [0, -24]) +/// |> line(end = [-24, 0]) +/// |> close() +/// |> extrude(length = 6) +/// ``` +/// +/// The `myPart` variable will be an executed `Solid` object. Executed being past +/// tense, because the engine has already executed the commands to create the solid. +/// +/// The previous solid commands will never be executed again, in this case. +/// +/// If you would like to encapsulate the commands to create the solid any time you call it, +/// you can use a function. +/// +/// ```kcl +/// fn createPart() { +/// return startSketchOn('XY') +/// |> startProfileAt([-12, 12], %) +/// |> line(end = [24, 0]) +/// |> line(end = [0, -24]) +/// |> line(end = [-24, 0]) +/// |> close() +/// |> extrude(length = 6) +/// } +/// ``` +/// +/// Now, every time you call `createPart()`, the commands will be +/// executed and a new solid will be created. +/// +/// When you assign the result of `createPart()` to a variable (`myPart = createPart()`), you are assigning +/// the executed solid to that variable. Meaning that the solid `myPart` will not be executed +/// again. +/// +/// You can still execute _new_ commands on the solid like `shell`, `fillet`, `chamfer`, etc. +/// and the solid will be updated. #[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)] #[ts(export)] #[serde(tag = "type", rename_all = "camelCase")] diff --git a/src/wasm-lib/kcl/src/execution/kcl_value.rs b/src/wasm-lib/kcl/src/execution/kcl_value.rs index b294d607e..bf5790b77 100644 --- a/src/wasm-lib/kcl/src/execution/kcl_value.rs +++ b/src/wasm-lib/kcl/src/execution/kcl_value.rs @@ -730,6 +730,7 @@ pub enum UnitType { } // TODO called UnitLen so as not to clash with UnitLength in settings) +/// A unit of length. #[derive(Debug, Default, Clone, Copy, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Eq)] #[ts(export)] #[serde(tag = "type")] @@ -811,6 +812,7 @@ impl From for kittycad_modeling_cmds::units::UnitLength { } } +/// A unit of angle. #[derive(Debug, Default, Clone, Copy, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Eq)] #[ts(export)] #[serde(tag = "type")]