@adobe/ccweb-add-on-sdk-types 1.0.0 → 1.1.1

package/{script/express.d.ts → sandbox/express-document-sdk.d.ts}

@@ -25,33 +25,13 @@
 import { mat2d } from "gl-matrix";
 
 declare namespace ApiConstants {
-    export {
-        SceneNodeTypeValueID,
-        BlendModeValue,
-        FillTypeValue,
-        ArrowHeadType,
-        TextAlignmentValue,
-        FillRuleValue,
-        StrokePositionValue
-    };
+    export { SceneNodeType, BlendMode, FillType, ArrowHeadType, TextAlignment, FillRule, StrokePosition };
 }
 
 declare interface ApiModuleExport {
     editor: ExpressEditor;
-    utils: ApiUtils;
-    Constants: unknown;
-}
-
-declare interface ApiUtils {
-    /**
-     * Create a new Color. All color components should be in a 0 - 1 range.
-     *
-     * @param red - The red component in a range from 0 - 1.
-     * @param green - The green component in a range from 0 - 1.
-     * @param blue - The blue component in a range from 0 - 1.
-     * @param alpha - (optional) The alpha component in a range from 0 - 1. Defaults to 1 (fully opaque).
-     */
-    createColor(red: number, green: number, blue: number, alpha?: number): Color;
+    constants: unknown;
+    colorUtils: ExpressColorUtils;
 }
 
 /**
@@ -76,21 +56,13 @@ declare enum ArrowHeadType {
  * ArtboardList also provides APIs for adding/removing artboards from the page. ArtboardList is never empty: it is illegal to
  * remove the last remaining artboard from the list.
  */
-export declare class ArtboardList extends ReadOnlyItemList<ArtboardNode> {
+export declare class ArtboardList extends RestrictedItemList<ArtboardNode> {
     /**
      * Create a new artboard and add it to the end of the list. The artboard size is the same as others on this page. The
      * artboard background is set to default fill color {@link DEFAULT_ARTBOARD_FILL_COLOR}.
      * @returns the newly added artboard.
      */
     addArtboard(): ArtboardNode;
-    /**
-     * Remove the items from the list.
-     *
-     * @throws An error if any of the items are not in the list or if removing the
-     * items would cause the list to be empty. If one of these errors occurs, the list
-     * is not modified.
-     */
-    remove(...items: ArtboardNode[]): void;
 }
 
 /**
@@ -98,7 +70,20 @@ export declare class ArtboardList extends ReadOnlyItemList<ArtboardNode> {
  *
  * When multiple artboards exist on a page, the artboards represent "scenes" in a linear timeline sequence.
  */
-export declare class ArtboardNode extends ContainerNode implements IRectangularNode, IStrokableNode {
+export declare class ArtboardNode extends BaseNode implements IRectangularNode, ContainerNode {
+    /**
+     * Returns a read-only list of all children of the node. General-purpose content containers such as ArtboardNode or
+     * GroupNode also provide a mutable {@link ContainerNode.children} list. Other nodes with a more specific structure can
+     * hold children in various discrete "slots"; this `allChildren` list includes *all* such children and reflects their
+     * overall display z-order.
+     *
+     * The children of an Artboard are always other Node classes (never the more minimal BaseNode).
+     */
+    get allChildren(): Readonly<Iterable<Node>>;
+    /**
+     * The node's children. Use the methods on this ItemList object to get, add, and remove children.
+     */
+    get children(): ItemList<Node>;
     /**
      * The node's parent. Undefined if the node is an orphan.
      */
@@ -112,14 +97,44 @@ export declare class ArtboardNode extends ContainerNode implements IRectangularN
      */
     get height(): number;
     /**
-     * The background fill of the artboard.
+     * The background fill of the artboard. Artboards must always have a fill.
      */
-    get fill(): Fill;
+    get fill(): Readonly<Fill>;
     set fill(fill: Fill);
+}
+
+/**
+ * A "node" represents an object in the scenegraph, the document's visual content tree. This base class includes only the
+ * most fundamental nonvisual properties that even nodes near the top of the document structure share (such as PageNode).
+ * The more tangible visual content typically extends the richer Node class which extends BaseNode with additional
+ * properties.
+ */
+export declare class BaseNode {
+    /**
+     * Returns a read-only list of all children of the node. General-purpose content containers such as ArtboardNode or
+     * GroupNode also provide a mutable {@link ContainerNode.children} list. Other nodes with a more specific structure can
+     * hold children in various discrete "slots"; this `allChildren` list includes *all* such children and reflects their
+     * overall display z-order.
+     *
+     * Although BaseNode's allChildren may yield other BaseNodes, the subclasses Node and ArtboardNode override allChildren
+     * to guarantee all their children are full-fledged Node instances.
+     */
+    get allChildren(): Readonly<Iterable<BaseNode>>;
+
+    /**
+     * The node's type.
+     */
+    get type(): SceneNodeType;
+    /**
+     * The node's parent. Undefined if the node is an orphan, or if the node is the artwork root.
+     */
+    get parent(): BaseNode | undefined;
     /**
-     * Any strokes(s) on the shape. Use the methods on this ItemList object to get, add, and remove strokes.
+     * Removes the node from its parent - for a basic ContainerNode, this is equivalent to `node.parent.children.remove(node)`.
+     * For nodes with other slots, removes the child from whichever slot it resides in, if possible. Throws if the slot does
+     * not support removal. Also throws if node is the artwork root. No-op if node is already an orphan.
      */
-    get strokes(): ItemList<Stroke>;
+    removeFromParent(): void;
 }
 
 /**
@@ -146,7 +161,7 @@ export declare interface BitmapImage {
  * If a node is inside a container whose blend mode anything other than {@link passThrough}, then the node's blend mode only
  * interacts with other siblings within the same container. See documentation below for details.
  */
-declare enum BlendModeValue {
+declare enum BlendMode {
     /**
      * This blend mode only applies to container nodes with children; for leaf nodes, it is treated the same as `normal`.
      *
@@ -182,33 +197,25 @@ declare enum BlendModeValue {
 }
 
 /**
- * Represents a color in a defined RGB colorspace. Value is immutable – to change, create a new Color object.
+ * Represents an RGBA color.
  */
-export declare class Color {
+export declare interface Color {
     /**
      * The red channel in range from 0 - 1.
      */
-    get red(): number;
+    red: number;
     /**
      * The green channel in range from 0 - 1.
      */
-    get green(): number;
+    green: number;
     /**
      * The blue channel in range from 0 - 1.
      */
-    get blue(): number;
+    blue: number;
     /**
      * The alpha channel in range from 0 - 1.
      */
-    get alpha(): number;
-    /**
-     * This color's color space. Currently only sRGB is supported.
-     */
-    get colorSpace(): ColorSpace;
-    /**
-     * Get the color in 8-digit hex "#RRGGBBAA" format.
-     */
-    getHex(): string;
+    alpha: number;
 }
 
 /**
@@ -218,28 +225,65 @@ export declare interface ColorFill extends Fill {
     /**
      * The fill type.
      */
-    readonly type: FillTypeValue.color;
+    readonly type: FillType.color;
     /**
      * The fill color.
      */
-    readonly color: Color;
+    color: Color;
 }
 
 /**
- * Available color spaces. Currently only sRGB is supported.
+ * Utility methods for working with color values.
  */
-export declare enum ColorSpace {
-    sRGB = "sRGB"
+export declare class ColorUtils {
+    /**
+     * Create a new Color. All color components should be in a 0 - 1 range.
+     *
+     * @param redOrPartialColor - The red component in a range from 0 - 1; or Partial Color object having alpha component as partial.
+     * @param green - The green component in a range from 0 - 1.
+     * @param blue - The blue component in a range from 0 - 1.
+     * @param alpha - (optional) The alpha component in a range from 0 - 1. Defaults to 1 (fully opaque).
+     */
+    fromRGB(red: number, green: number, blue: number, alpha?: number): Color;
+    fromRGB(color: { red: number; green: number; blue: number; alpha?: number }): Color;
+    /**
+     * Create a new color from its equivalent RGBA hex representation. Currently only
+     * supports formats "#RRGGBBAA" or "RRGGBBAA". If the hex value is invalid, this
+     * method will return transparent black.
+     *
+     * @param hex - The color in hex representation.
+     * @returns A new color matching the given hex representation, or transparent black if
+     * the hex string cannot be parsed.
+     */
+    fromHex(hex: string): Color;
+    /**
+     * Get the color in 8-digit hex "#RRGGBBAA" format.
+     * @privateRemarks
+     * Future: Since this format is only valid for the sRGB color space, if the color is in another color space once other
+     * spaces are supported, the value return here would be a lossy conversion.
+     */
+    toHex(color: Color): string;
 }
 
-export declare const Constants: typeof ApiConstants;
+export declare const colorUtils: ExpressColorUtils;
+
+/**
+ * A ComplexShapeNode is complex prepackaged shape that appears as a leaf node in the UI, even if it is composed
+ * of multiple separate paths.
+ */
+export declare class ComplexShapeNode extends FillableNode {}
+
+export declare const constants: typeof ApiConstants;
 
 /**
- * Base class for a Node that contains an entirely generic collection of children. Some ContainerNode subclasses may host
+ * Interface for any node that contains an entirely generic collection of children. Some ContainerNode classes may host
  * *additional* children in other specific "slots," such as background or mask layers; and non-ContainerNode classes may
  * also hold children in specified "slots." Use {@link Node.allChildren} for read access to children regardless of node type.
+ *
+ * Some ContainerNode classes may be full-fledged Node subclasses (such as Group), while others may be a subclass of the
+ * more minimal BaseNode (such as Artboard).
  */
-export declare class ContainerNode extends Node {
+export declare interface ContainerNode extends BaseNode {
     /**
      * The node's children. Use the methods on this ItemList object to get, add, and remove children.
      */
@@ -254,6 +298,13 @@ export declare class Context {
      * @returns the current selection. Nodes that are locked or otherwise non-editable are never included in the selection.
      */
     get selection(): readonly Node[];
+    /**
+     * Sets the current selection, automatically ensuring these rules are met:
+     * - Nodes must be within the current artboard (others are filtered out).
+     * - A node cannot be selected at the same time as its ancestor (descendants are filtered out).
+     * - Locked nodes are filtered out (but will still be included in selectionIncludingNonEditable).
+     */
+    set selection(nodes: Node | readonly Node[] | undefined);
     /**
      * @returns the current selection *and* any locked nodes the user has attempted to select at the same time. This can
      * happen for example if the user clicks on a locked node or if the user drags a selection marquee that overlaps
@@ -283,12 +334,12 @@ export declare class Editor {
      */
     get documentRoot(): ExpressRootNode;
     /**
-     * @returns an ellipse node with default x/y radii, and *no* initial stroke or fill.
+     * @returns an ellipse node with default x/y radii, a black fill, and no initial stroke.
      * Transform values default to 0.
      */
     createEllipse(): EllipseNode;
     /**
-     * @returns a rectangle node with default width and height, and *no* initial stroke or fill.
+     * @returns a rectangle node with default width and height, a black fill, and no initial stroke.
      * Transform values default to 0.
      */
     createRectangle(): RectangleNode;
@@ -302,10 +353,10 @@ export declare class Editor {
      */
     createGroup(): GroupNode;
     /**
+     * Convenience helper to create a complete ColorFill value given just its color.
      * @param color - The color to use for the fill.
-     * @returns a solid color fill.
      */
-    createColorFill(color: Color): ColorFill;
+    makeColorFill(color: Color): ColorFill;
     /**
      * Creates a bitmap image, represented as a multi-node MediaContainerNode structure. Always creates a "full-frame,"
      * uncropped image initially, but cropping can be changed after it is created by modifying the properties of the
@@ -340,27 +391,62 @@ export declare class Editor {
      */
     loadBitmapImage(bitmapData: Blob): Promise<BitmapImage>;
     /**
-     * See {@link StrokeOptions} for more details on the `options` fields. Defaults:
+     * Convenience helper to create a complete Stroke value given just a subset of its fields. All other fields are
+     * populated with default values.
+     *
+     * See {@link Stroke} for more details on the `options` fields. Defaults:
      * - `color` has default value {@link DEFAULT_STROKE_COLOR} if none is provided.
      * - `width` has default value {@link DEFAULT_STROKE_WIDTH} if none is provided.
-     * - `dashPattern` has default value [] if none is provided. If the dash pattern has
-     *   odd number of elements, the items are copied to double the array. For example,
-     *   [1, 2, 3] becomes [1, 2, 3, 1, 2, 3]. Values cannot be negative.
-     * - `dashOffset` has default value 0 if none is provided. This options field is ignored
+     * - `position` has default value `center` if none is provided.
+     * - `dashPattern` has default value [] if none is provided.
+     * - `dashOffset` has default value 0 if none is provided. This field is ignored
      *   if no `dashPattern` was provided.
      *
-     * The stroke's `position` field cannot be specified via options yet because only
-     * {@link StrokePositionValue.center} is supported.
-     *
      * @returns a stroke configured with the given options.
      */
-    createStroke(options?: Partial<StrokeOptions>): Stroke;
+    makeStroke(options?: Partial<Stroke>): Stroke;
     /**
      * @returns a text node with default styles. The text content is initially empty, so the text node will be
      * invisible until its `text` property is set. Creates point text, so the node's width will automatically
      * adjust to accommodate whatever text is set.
      */
     createText(): TextNode;
+    /**
+     * Enqueues a function to be run at a later time when edits to the user's document may be performed. You can always edit
+     * the document immediately when invoked in response to your add-on's UI code. However, if you delay to await an
+     * asynchronous operation such as {@link loadBitmapImage}, any edits following this pause must be scheduled using
+     * queueAsyncEdit(). This ensures the edit is properly tracked for saving and undo.
+     *
+     * The delay before your edit function is executed is typically just a few milliseconds, so it will appear instantaneous
+     * to users. However, note that queueAsyncEdit() will return *before* your function has been run.
+     * If you need to trigger any code after the edit has been performed, either include this in the lambda you are enqueuing
+     * or await the Promise returned by queueAsyncEdit().
+     *
+     * Generally, calling any setter or method is treated as an edit; but simple getters may be safely called at any time.
+     *
+     * Example of typical usage:
+     * ```javascript
+     * // Assume insertImage() is called from your UI code, and given a Blob containing image data
+     * async function insertImage(blob) {
+     *     // This function was invoked from the UI iframe, so we can make any edits we want synchronously here.
+     *     // Initially load the bitmap - an async operation
+     *     const bitmapImage = await editor.loadBitmapImage(blob);
+     *
+     *     // Execution doesn't arrive at this line until an async delay, due to the Promise 'await' above
+     *
+     *     // Further edits need to be queued to run at a safe time
+     *     editor.queueAsyncEdit(() => {
+     *          // Create scenenode to display the image, and add it to the current artboard
+     *          const mediaContainer = editor.createImageContainer(bitmapImage);
+     *          editor.context.insertionParent.children.append(mediaContainer);
+     *     });
+     * }
+     * ```
+     *
+     * @param lambda - a function which edits the document model.
+     * @returns a Promise that resolves when the lambda has finished running, or rejects if the lambda throws an error.
+     */
+    queueAsyncEdit(lambda: () => void): Promise<void>;
 }
 
 export declare const editor: ExpressEditor;
@@ -392,12 +478,14 @@ export declare class EllipseNode extends FillableNode {
 declare const expressApiModule: ApiModuleExport;
 export default expressApiModule;
 
+declare class ExpressColorUtils extends ColorUtils {}
+
 declare class ExpressEditor extends Editor {}
 
 /**
  * An ExpressRootNode represents the root node of the document's "scenegraph" artwork tree.
  */
-export declare class ExpressRootNode extends Node {
+export declare class ExpressRootNode extends BaseNode {
     /**
      * The pages of the document. All visual content is contained on artboards within the pages.
      */
@@ -411,7 +499,7 @@ export declare interface Fill {
     /**
      * The fill type.
      */
-    readonly type: FillTypeValue;
+    readonly type: FillType;
 }
 
 /**
@@ -419,16 +507,17 @@ export declare interface Fill {
  */
 export declare class FillableNode extends StrokableNode implements IFillableNode {
     /**
-     * Any fill(s) on the shape. Use the methods on this ItemList object to get, add, and remove fills.
+     * The fill applied to the shape, if any.
      */
-    get fills(): ItemList<Fill>;
+    get fill(): Readonly<Fill> | undefined;
+    set fill(fill: Fill | undefined);
 }
 
 /**
  * <InlineAlert slots="text" variant="warning"/>
  * *Do not depend on the literal numeric values of these constants*, as they may change. Always reference the enum identifiers in your code.
  */
-declare enum FillRuleValue {
+declare enum FillRule {
     nonZero = 0,
     evenOdd = 1
 }
@@ -441,16 +530,36 @@ declare enum FillRuleValue {
  * *Additional fill types may be added in the future.* If your code has different branches or cases depending on fill type,
  * always have a default/fallback case to handle any unknown values you may encounter.
  */
-declare enum FillTypeValue {
+declare enum FillType {
     /** A solid color fill. */
     color = "Color"
 }
 
+/**
+ * A GridLayoutNode represents a grid layout in the scenegraph. The GridLayoutNode is used to
+ * create a layout grid that other content can be placed into.
+ */
+export declare class GridLayoutNode extends Node implements IRectangularNode {
+    /**
+     * The width of the node.
+     */
+    get width(): number;
+    /**
+     * The height of the node.
+     */
+    get height(): number;
+    /**
+     * The background fill of the GridLayout.
+     */
+    get fill(): Readonly<Fill>;
+    set fill(fill: Fill);
+}
+
 /**
  * A GroupNode represents a Group object in the scenegraph, which has a collection of generic children as well as a separate,
  * optional vector mask child.
  */
-export declare class GroupNode extends ContainerNode {
+export declare class GroupNode extends Node implements ContainerNode {
     /**
      * The Group's regular children. Does not include the maskShape if one is present.
      * Use the methods on this ItemList object to get, add, and remove children.
@@ -463,7 +572,7 @@ export declare class GroupNode extends ContainerNode {
      */
     get maskShape(): FillableNode | undefined;
     /**
-     * If set to a vector shape, adds a mask or replaces the exsiting mask on this Group.
+     * If set to a vector shape, adds a mask or replaces the existing mask on this Group.
      * If set to undefined, removes any mask that was previously set on this Group.
      * @throws if the given node type cannot be used as a vector mask.
      */
@@ -471,11 +580,11 @@ export declare class GroupNode extends ContainerNode {
 }
 
 /**
- * Interface for {@link FillableNode} *and* any other nodes with a similar `fills` API that do not directly inherit from the
- * FillableNode class.
+ * Interface for {@link FillableNode} *and* any other nodes with a similar `fill` property that do not directly inherit from
+ * the FillableNode class.
  */
 declare interface IFillableNode {
-    fills: ItemList<Fill>;
+    fill: Fill | undefined;
 }
 
 /**
@@ -507,11 +616,11 @@ declare interface IRectangularNode {
 }
 
 /**
- * Interface for {@link StrokableNode} *and* any other nodes with a similar `strokes` API that do not directly inherit from
- * the StrokableNode class. (See {@link ArtboardNode}, for example).
+ * Interface for {@link StrokableNode} *and* any other nodes with a similar `stroke` property that do not directly inherit
+ * from the StrokableNode class. (See {@link ArtboardNode}, for example).
  */
 declare interface IStrokableNode {
-    strokes: ItemList<Stroke>;
+    stroke: Stroke | undefined;
 }
 
 /**
@@ -523,17 +632,12 @@ declare interface IStrokableNode {
  *
  * This class is used in different places for various types of items, including Nodes, Fills, and Strokes.
  */
-export declare class ItemList<T extends ListItem> extends ReadOnlyItemList<T> {
+export declare class ItemList<T extends ListItem> extends RestrictedItemList<T> {
     /**
      * Add one or more items to the end of the list. The last argument will become the last item in this list. Items are
      * removed from their previous parent, if any – or if an item is already in *this* list, its index is simply changed.
      */
     append(...items: T[]): void;
-    /**
-     * Remove one or more items from this list. The items need not be contiguous.
-     * Throws without performing any removals if any item is not a member of this list.
-     */
-    remove(...items: T[]): void;
     /**
      * Remove all items from this list. No-op if list is already empty.
      */
@@ -568,8 +672,8 @@ export declare class LineNode extends StrokableNode {
     static readonly DEFAULT_END_Y = 100;
     /**
      * Set the start and end points of the line in its local coordinate space (which may
-     * differ from its parent's coordinate space based on `relativeTransform`, i.e.
-     * `relativeRotation` and `translateX`/`Y`). The values passed in may be normalized
+     * differ from its parent's coordinate space based on `transformMatrix`, i.e.
+     * `rotation` and `translation`). The values passed in may be normalized
      * by this setter, shifting the node's translation and counter-shifting the start/end
      * points. Therefore, the start/end getters may return values different from the values
      * you passed into this setter, even though the line's visual bounds and appearance are
@@ -593,31 +697,23 @@ export declare class LineNode extends StrokableNode {
      */
     get endY(): number;
     /**
-     * The shape encapsulating the start of a line. The size and color of the arrowhead
-     * depends on the first available stroke's weight and color assigned to the node.
-     * Removal of all strokes on this line leads to the arrowhead's removal.
+     * The shape encapsulating the start of a line.
      *
-     * The getter returns {@link ArrowHeadType.none} when there are no strokes on the line
-     * or no arrowhead on the first stroke of the line.
+     * Returns {@link ArrowHeadType.none} if there is no stroke on the line.
      */
     get startArrowHeadType(): ArrowHeadType;
     /**
-     * The setter creates a default stroke for the line when there are no strokes on the line,
-     * and updates the arrowhead on only the first stroke of the line.
+     * The setter sets a default stroke on the line if it did not have one.
      */
     set startArrowHeadType(type: ArrowHeadType);
     /**
-     * The shape encapsulating the end of a line. The size and color of the arrowhead
-     * depends on the first available stroke's weight and color assigned to the node.
-     * Removal of all strokes on this line leads to the arrowhead's removal.
+     * The shape encapsulating the end of a line.
      *
-     * The getter returns {@link ArrowHeadType.none} when there are no strokes on the line
-     * or no arrowhead on the first stroke of the line.
+     * Returns {@link ArrowHeadType.none} if there is no stroke on the line.
      */
     get endArrowHeadType(): ArrowHeadType;
     /**
-     * The setter creates a default stroke for the line when there are no strokes on the line,
-     * and updates the arrowhead on only the first stroke of the line.
+     * The setter sets a default stroke on the line if it did not have one.
      */
     set endArrowHeadType(type: ArrowHeadType);
 }
@@ -649,53 +745,70 @@ export declare class MediaContainerNode extends Node {
 }
 
 /**
- * A Node represents an object in the scenegraph, the document's visual content tree.
+ * A Node represents an object in the scenegraph, the document's visual content tree. Most tangible visual content is a
+ * subclass of Node, but note that some abstract top-level structural nodes (such as PageNode) only extend the more minimal
+ * BaseNode. As a general rule, if you can click or drag an object with the select/move tool in the UI, then it extends
+ * from Node.
  */
-declare class Node {
+declare class Node extends BaseNode {
     /**
      * Returns a read-only list of all children of the node. General-purpose content containers such as ArtboardNode or
      * GroupNode also provide a mutable {@link ContainerNode.children} list. Other nodes with a more specific structure can
      * hold children in various discrete "slots"; this `allChildren` list includes *all* such children and reflects their
      * overall display z-order.
+     *
+     * The children of a Node are always other Node classes (never the more minimal BaseNode).
      */
     get allChildren(): Readonly<Iterable<Node>>;
-
-    /**
-     * The node's type.
-     */
-    get type(): SceneNodeTypeValueID;
     /**
-     * The translation of the node along its parent's x-axis.
-     */
-    get translateX(): number;
-    set translateX(value: number);
-    /**
-     * The translation of the node along its parent's y-axis.
-     */
-    get translateY(): number;
-    set translateY(value: number);
-    /**
-     * The node's local rotation value in degrees, relative to its parent's axes. Modifying this value will also adjust the
-     * node's x & y translation such that the node's center is in the same location after the rotation – i.e. this setter
-     * rotates the node about its bounding box's center, not its origin.
-     */
-    get relativeRotation(): number;
-    set relativeRotation(value: number);
-    /**
-     * The node's absolute (global) rotation angle in degrees – includes any cumulative rotation from the node's parent containers.
-     */
-    get absoluteRotation(): number;
-    set absoluteRotation(value: number);
-    /**
-     * The node's parent. Undefined if the node is an orphan, or if the node is the artwork root.
-     */
-    get parent(): Node | undefined;
-    /**
-     * Removes the node from its parent - for a basic ContainerNode, this is equivalent to `node.parent.children.remove(node)`.
-     * For nodes with other slots, removes the child from whichever slot it resides in, if possible. Throws if the slot does
-     * not support removal. Also throws if node is the artwork root. No-op if node is already an orphan.
-     */
-    removeFromParent(): void;
+     * The translation of the node along its parent's axes. This is identical to the translation component of
+     * `transformMatrix`. It is often simpler to set a node's position using `setPositionInParent` than by
+     * setting translation directly.
+     */
+    get translation(): Readonly<{
+        x: number;
+        y: number;
+    }>;
+    set translation(value: { x: number; y: number });
+    /**
+     * Move the node so the given `localRegistrationPoint` in its local coordinates is placed at the given
+     * `parentPoint` in its parent's coordinates (taking into account any rotation on this node, etc.).
+     * @param parentPoint - Point in this node's parent's coordinate space to move `localRegistrationPoint` to
+     * @param localRegistrationPoint - Point in this node's local coordinate space to align with `parentPoint`
+     * @example
+     * Center a rectangle within its parent artboard:
+     * ```
+     * rectangle.setPositionInParent(
+     *     { x: artboard.width / 2, y: artboard.height / 2 },
+     *     { x: rectangle.width / 2, y: rectangle.height / 2 }
+     * );
+     * ```
+     */
+    setPositionInParent(parentPoint: Point, localRegistrationPoint: Point): void;
+    /**
+     * The node's local rotation angle in degrees, relative to its parent's axes. Use `setRotationInParent` to
+     * change rotation by rotating around a defined centerpoint.
+     */
+    get rotation(): number;
+    /**
+     * Set the node’s rotation angle relative to its parent to exactly the given value, keeping the given point in the
+     * node’s local coordinate space at a fixed location within the parent. Disregards any rotation the node may already
+     * have had. The angle set here may not be the absolute rotation angle seen on screen, if the parent or other
+     * ancestors have any rotation of their own.
+     * @param angleInDegrees - Angle in degrees.
+     * @param localRotationPoint - Point to rotate around, in node's local coordinates.
+     * @example
+     * Rotate the rectangle 45 degrees clockwise around its centerpoint:
+     * ```
+     * rectangle.setRotationInParent(45, { x: rectangle.width / 2, y: rectangle.height / 2 });
+     * ```
+     */
+    setRotationInParent(angleInDegrees: number, localRotationPoint: Point): void;
+    /**
+     * The node's total rotation angle in degrees, relative to the overall global view of the document – including any
+     * cumulative rotation from the node's parent containers.
+     */
+    get rotationInScreen(): number;
     /**
      * The node's opacity, from 0.0 to 1.0
      */
@@ -704,11 +817,7 @@ declare class Node {
     /**
      * The node's transform matrix relative to its parent.
      */
-    get relativeTransform(): mat2d;
-    /**
-     * The node's absolute (global) transform matrix.
-     */
-    get absoluteTransform(): mat2d;
+    get transformMatrix(): mat2d;
     /**
      * The node's lock/unlock state. Locked nodes are excluded from the selection (see {@link Context.selection}), and
      * cannot be edited by the user unless they are unlocked first.
@@ -717,10 +826,10 @@ declare class Node {
     set locked(locked: boolean);
     /**
      * Blend mode determines how a node is composited onto the content below it. The default value is
-     * {@link BlendModeValue.normal} for most nodes, and {@link BlendModeValue.passThrough} for GroupNodes.
+     * {@link BlendMode.normal} for most nodes, and {@link BlendMode.passThrough} for GroupNodes.
      */
-    get blendMode(): BlendModeValue;
-    set blendMode(value: BlendModeValue);
+    get blendMode(): BlendMode;
+    set blendMode(value: BlendMode);
 }
 export { Node as Node };
 
@@ -732,7 +841,7 @@ export { Node as Node };
  * PageList also provides APIs for adding/removing pages from the document. PageList is never empty: it is illegal to
  * remove the last remaining page from the list.
  */
-export declare class PageList extends ReadOnlyItemList<PageNode> {
+export declare class PageList extends RestrictedItemList<PageNode> {
     /**
      * Create a new page containing a single empty artboard, and add it to the end of the list. The artboard is configured
      * with the same defaults as in {@link ArtboardList.addArtboard}. The page's artboard becomes the default target for
@@ -746,7 +855,7 @@ export declare class PageList extends ReadOnlyItemList<PageNode> {
  * A PageNode represents a page in the document. A page contains one or more artboards, representing "scenes" in a linear
  * timeline sequence. Those artboards in turn contain all the visual content of the document.
  */
-export declare class PageNode extends Node implements Readonly<IRectangularNode> {
+export declare class PageNode extends BaseNode implements Readonly<IRectangularNode> {
     /**
      * The artboards or "scenes" of a page, ordered by timeline sequence.
      */
@@ -768,6 +877,32 @@ export declare class PageNode extends Node implements Readonly<IRectangularNode>
     set name(name: string | undefined);
 }
 
+/**
+ * A PathNode represents a generic vector path shape in the scenegraph. Paths cannot be created or edited through this API
+ * yet, only read.
+ */
+export declare class PathNode extends FillableNode {
+    /**
+     * The path definition as an SVG string. The path data is read-only and cannot be modified via this API yet.
+     * Example: "M 0 0 L 10 15".
+     */
+    get path(): string;
+    /**
+     * The fill rule specifies how the interior area of a path is determined in cases where the path is self-intersecting or
+     * has multiple disjoint parts. This value is read-only and cannot be modified via this API yet.
+     */
+    get fillRule(): FillRule;
+}
+
+/**
+ * Represents a 2D position.
+ * @public
+ */
+export declare interface Point {
+    x: number;
+    y: number;
+}
+
 /**
  * ReadOnlyItemList represents an ordered list of API objects, representing items that are all children of the
  * same parent node. (The reverse is not necessarily true, however: this list might not include all
@@ -788,6 +923,11 @@ export declare class ReadOnlyItemList<T extends ListItem> {
      * Last item in this list, or undefined if list is empty.
      */
     get last(): T | undefined;
+    /**
+     * Get index of item in list.
+     * @returns index number, or -1 if item isn't in this list.
+     */
+    indexOf(item: T): number;
     /**
      * Returns item at the given index, or undefined if index is out of range.
      * @param index - Zero-based index
@@ -875,6 +1015,35 @@ export declare class RectangleNode extends FillableNode implements IRectangularN
     setUniformCornerRadius(radius: number): void;
 }
 
+/**
+ * Base for ItemLists that have restricted behavior on how items are added to the list,
+ * but allow items to be removed and reordered. Subclasses like ItemList may add more
+ * capabilities, however.
+ */
+declare class RestrictedItemList<T extends ListItem> extends ReadOnlyItemList<T> {
+    /**
+     * Remove the items from the list. The items need not be contiguous.
+     * @throws If any of the items are not in the list, or if it is illegal to remove any of the items from this parent.
+     */
+    remove(...items: T[]): void;
+    /**
+     * Move `item` so it is immediately before `before` in this list: places `item` at the index that `before` used
+     * to occupy. Depending on the position in the list `item` originally occupied, some other items in the list may
+     * shift to higher or lower indices as a result. No-op if both arguments are the same item.
+     *
+     * @throws An error if either argument is not contained in this list.
+     */
+    moveBefore(item: T, before: T): void;
+    /**
+     * Move `item` so it is immediately after `after` in this list: places `item` at the index one higher than `after`.
+     * Depending on the position in the list `item` originally occupied, some other items in the list may shift to higher
+     * or lower indices as a result. No-op if both arguments are the same item.
+     *
+     * @throws An error if either argument is not contained in this list.
+     */
+    moveAfter(item: T, after: T): void;
+}
+
 /**
  * <InlineAlert slots="text" variant="warning"/>
  * *Do not depend on the literal string values of these constants*, as they may change. Always reference the enum identifiers in your code.
@@ -883,7 +1052,7 @@ export declare class RectangleNode extends FillableNode implements IRectangularN
  * *Additional node types may be added in the future.* If your code has different branches or cases depending on node type,
  * always have a default/fallback case to handle any unknown values you may encounter.
  */
-declare enum SceneNodeTypeValueID {
+declare enum SceneNodeType {
     line = "Line",
     rectangle = "Rectangle",
     ellipse = "Ellipse",
@@ -899,52 +1068,67 @@ declare enum SceneNodeTypeValueID {
     /** Type of MediaContainerNode's "media rectangle" child when it is holding an image */
     imageRectangle = "ImageRectangle",
     /** Type of PageNode */
-    page = "Page"
+    page = "Page",
+    /** Type of ComplexShapeNode, representing a complex prepackaged shape with fill and stroke, that appears as a leaf node in the UI */
+    complexShape = "ComplexShape",
+    /** Type of SolidColorShapeNode, representing a solid-color prepackaged shape that appears as a leaf node in the UI */
+    solidColorShape = "SolidColorShape",
+    /** Type of StrokeShapeNode, representing a stroke-only prepackaged shape that appears as a leaf node in the UI */
+    strokeShape = "StrokeShape",
+    /** Type of GridLayoutNode represents a grid layout in the scenegraph used to create a layout grid that other content can be placed into */
+    gridLayout = "GridLayout"
 }
 
 /**
- * Base class for a Node that can have its own stroke.
+ * A SolidColorShapeNode is a prepackaged shape with a single color property that appears as a leaf node in the UI, even if it
+ * is composed of multiple separate paths.
  */
-export declare class StrokableNode extends Node implements IStrokableNode {
-    static DEFAULT_STROKE_WIDTH: number;
+export declare class SolidColorShapeNode extends Node {
     /**
-     * Any stroke(s) on the shape. Use the methods on this ItemList object to get, add, and remove strokes.
+     * The color of the single color shape.
      */
-    get strokes(): ItemList<Stroke>;
+    get color(): Readonly<Color> | undefined;
+    set color(color: Color | undefined);
 }
 
 /**
- * Represents a stroke in the scenegraph. See {@link StrokableNode}.
+ * Base class for a Node that can have its own stroke.
  */
-export declare interface Stroke extends StrokeOptions {
+export declare class StrokableNode extends Node implements IStrokableNode {
     /**
-     * The position of the stroke relative to the outline of the shape.
+     * The stroke applied to the shape, if any.
      */
-    readonly position: StrokePositionValue;
+    get stroke(): Readonly<Stroke> | undefined;
+    set stroke(stroke: Stroke | undefined);
 }
 
 /**
- * Properties that can be provided to create a stroke.
+ * Represents a stroke in the scenegraph. See {@link StrokableNode}.
  */
-export declare interface StrokeOptions {
+export declare interface Stroke {
     /**
      * The color of a stroke.
      */
-    readonly color: Color;
+    color: Color;
     /**
      * The thickness of a stroke. Must be from {@link MIN_STROKE_WIDTH} to {@link MAX_STROKE_WIDTH}.
      */
-    readonly width: number;
+    width: number;
     /**
      * If empty, this is a solid stroke.
      * If non-empty, the values alternate between length of a rendered and blank segment,
      * repeated along the length of the stroke. The first value represents the first solid segment.
+     * Array must be of even length. Values cannot be negative.
      */
-    readonly dashPattern: number[];
+    dashPattern: number[];
     /**
      * Number of pixels the beginning of dash pattern should be offset along the stroke.
      */
-    readonly dashOffset: number;
+    dashOffset: number;
+    /**
+     * The position of the stroke relative to the outline of the shape.
+     */
+    position: StrokePosition;
 }
 
 /**
@@ -953,17 +1137,23 @@ export declare interface StrokeOptions {
  *
  * A stroke's {@link Stroke.position} determines how the thickness of the stroke is aligned along a shape's path outline.
  */
-declare enum StrokePositionValue {
+declare enum StrokePosition {
     center = 0,
     inside = 1,
     outside = 2
 }
 
+/**
+ * A StrokeShapeNode is prepackaged shape that has a single stroke property and appears as a leaf node in the UI, even
+ * if it is composed of multiple separate paths.
+ */
+export declare class StrokeShapeNode extends StrokableNode {}
+
 /**
  * <InlineAlert slots="text" variant="warning"/>
  * *Do not depend on the literal numeric values of these constants*, as they may change. Always reference the enum identifiers in your code.
  */
-declare enum TextAlignmentValue {
+declare enum TextAlignment {
     left = 1,
     right = 2,
     center = 3
@@ -981,10 +1171,13 @@ export declare class TextNode extends Node {
     /**
      * The horizontal text alignment of the text node. Alignment is always the same across this node's entire text content.
      */
-    get textAlignment(): TextAlignmentValue;
-    set textAlignment(alignment: TextAlignmentValue);
+    get textAlignment(): TextAlignment;
+    set textAlignment(alignment: TextAlignment);
 }
 
-export declare const utils: ApiUtils;
+/**
+ * An UnknownNode is a node with limited support and therefore treated as a leaf node.
+ */
+export declare class UnknownNode extends Node {}
 
 export {};