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

package/README.md

@@ -12,8 +12,8 @@ This package exports type definitions for [@adobe/create-ccweb-add-on](https://w
 
 For TypeScript add-on projects created using [@adobe/create-ccweb-add-on](https://www.npmjs.com/package/@adobe/create-ccweb-add-on), this package is pre-installed. Additionally, the below files are included in the add-on project (based on the selected runtime):
 
--   [add-on-ui-sdk.d.ts](https://github.com/adobe/ccweb-add-on-cli/blob/main/packages/wxp-sdk-typings/add-on-script-sdk.d.ts)
--   [add-on-script-sdk.d.ts](https://github.com/adobe/ccweb-add-on-cli/blob/main/packages/wxp-sdk-typings/add-on-ui-sdk.d.ts)
+-   [add-on-ui-sdk.d.ts](https://github.com/adobe/create-ccweb-add-on/blob/main/packages/wxp-sdk-types/add-on-ui-sdk.d.ts)
+-   [add-on-sandbox-sdk.d.ts](https://github.com/adobe/create-ccweb-add-on/blob/main/packages/wxp-sdk-types/add-on-sandbox-sdk.d.ts)
 
 However, if you are installing this package on your existing add-on project, ensure to include the above type definition files in your `src` directory.
 

package/{add-on-script-sdk.d.ts → add-on-sandbox-sdk.d.ts}

@@ -24,12 +24,12 @@
 
 // DO NOT modify this file.
 
-declare module "AddOnScriptSdk" {
-    import { AddOnScriptSdkTypes } from "@adobe/ccweb-add-on-sdk-types";
-    export default AddOnScriptSdkTypes.default;
-    export * from "@adobe/ccweb-add-on-sdk-types/script/script-sdk";
+declare module "add-on-sdk-document-sandbox" {
+    import { AddOnDocumentSandboxSdkTypes } from "@adobe/ccweb-add-on-sdk-types";
+    export default AddOnDocumentSandboxSdkTypes.default;
+    export * from "@adobe/ccweb-add-on-sdk-types/sandbox/add-on-sdk-document-sandbox";
 }
 
-declare module "express" {
-    export * from "@adobe/ccweb-add-on-sdk-types/script/express";
+declare module "express-document-sdk" {
+    export * from "@adobe/ccweb-add-on-sdk-types/sandbox/express-document-sdk";
 }

package/index.d.ts

@@ -22,5 +22,5 @@
  * SOFTWARE.
  ********************************************************************************/
 
-export * as AddOnScriptSdkTypes from "./script/index.js";
+export * as AddOnDocumentSandboxSdkTypes from "./sandbox/index.js";
 export * as AddOnUISdkTypes from "./ui/index.js";

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@adobe/ccweb-add-on-sdk-types",
-    "version": "1.0.0",
+    "version": "1.1.0",
     "author": "Adobe",
     "license": "MIT",
     "description": "Type definitions for Adobe Creative Cloud Web Add-on SDK.",
@@ -18,7 +18,6 @@
     },
     "dependencies": {
         "tslib": "2.4.0",
-        "comlink": "4.3.1",
         "gl-matrix": "3.3.0"
     },
     "devDependencies": {

package/sandbox/add-on-sdk-document-sandbox.d.ts

@@ -0,0 +1,236 @@
+/********************************************************************************
+ * MIT License
+
+ * © Copyright 2023 Adobe. All rights reserved.
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ ********************************************************************************/
+
+/**
+ * Represents the instance of this AddOn.
+ * The instance contains the necessary details like the associated Runtime etc.
+ */
+export declare class AddOn {
+    /**
+     * Get the runtime instance, which represents
+     * the execution environment for this AddOn.
+     */
+    get runtime(): Runtime;
+}
+
+/**
+ * The APIs provided by AddOn SDK for the document model sandbox.
+ * The APIs are exposed as an ES6 module.
+ * @public
+ */
+export declare class AddOnDocumentSandboxSdk {
+    /**
+     * Returns the instance of this AddOn.
+     * @see AddOn
+     */
+    get instance(): AddOn;
+}
+
+/** @public - This object, exposed as the default, can be used in add-on's document model sandbox code. */
+declare const addOnSandboxSdk: AddOnDocumentSandboxSdk;
+export default addOnSandboxSdk;
+
+/**
+ * Takes the raw type of a remote object or function as a remote thread would see it through a proxy (e.g. when
+ * passed in as a function argument) and returns the type the local thread has to supply.
+ * Creation of new class objects is not allowed.
+ *
+ * This is the inverse of `Remote<T>`. It takes a `Remote<T>` and returns its original input `T`.
+ */
+declare type Local<T> = LocalObject<T> &
+    (T extends (...args: infer TArguments) => infer TReturn
+        ? (
+              ...args: {
+                  [I in keyof TArguments]: ProxyOrClone<TArguments[I]>;
+              }
+          ) => MaybePromise<UnproxyOrClone<Unpromisify<TReturn>>>
+        : unknown) &
+    (T extends {
+        new (...args: infer TArguments): infer TInstance;
+    }
+        ? {
+              new: never;
+          }
+        : unknown);
+
+/**
+ * Takes the type of an object as a remote thread would see it through a proxy (e.g. when passed in as a function
+ * argument) and returns the type that the local thread has to supply.
+ *
+ * This does not handle call signatures, which is handled by the more general `Local<T>` type.
+ *
+ * This is the inverse of `RemoteObject<T>`.
+ *
+ * @template T The type of a proxied object.
+ */
+declare type LocalObject<T> = {
+    [P in keyof T]: LocalProperty<T[P]>;
+};
+
+/**
+ * Takes the raw type of a property as a remote thread would see it through a proxy (e.g. when passed in as a function
+ * argument) and returns the type that the local thread has to supply.
+ *
+ * This is the inverse of `RemoteProperty<T>`.
+ *
+ * Note: This needs to be its own type alias, otherwise it will not distribute over unions. See
+ * https://www.typescriptlang.org/docs/handbook/advanced-types.html#distributive-conditional-types
+ */
+declare type LocalProperty<T> = T extends Function | ProxyMarked ? Local<T> : Unpromisify<T>;
+
+/**
+ * Expresses that a type can be either a sync or async.
+ */
+declare type MaybePromise<T> = Promise<T> | T;
+
+/**
+ * Takes a type and wraps it in a Promise, if it not already is one.
+ * This is to avoid `Promise<Promise<T>>`.
+ *
+ * This is the inverse of `Unpromisify<T>`.
+ */
+declare type Promisify<T> = T extends Promise<unknown> ? T : Promise<T>;
+
+/**
+ * Interface of values that were marked to be proxied with `Runtime.apiProxy()`.
+ * Can also be implemented by classes.
+ */
+declare interface ProxyMarked {
+    [proxyMarker]: true;
+}
+
+declare const proxyMarker: unique symbol;
+
+/**
+ * Proxies `T` if it is a `ProxyMarked`, clones it otherwise (as handled by structured cloning and transfer handlers).
+ */
+declare type ProxyOrClone<T> = T extends ProxyMarked ? Remote<T> : T;
+
+/**
+ * Takes the raw type of a remote object or function in the other thread and returns the type as it is visible to
+ * the local thread from the proxy return value of `Runtime.apiProxy()`.
+ * Creation of new class objects is not allowed.
+ */
+declare type Remote<T> = RemoteObject<T> &
+    (T extends (...args: infer TArguments) => infer TReturn
+        ? (
+              ...args: {
+                  [I in keyof TArguments]: UnproxyOrClone<TArguments[I]>;
+              }
+          ) => Promisify<ProxyOrClone<Unpromisify<TReturn>>>
+        : unknown) &
+    (T extends {
+        new (...args: infer TArguments): infer TInstance;
+    }
+        ? {
+              new: never;
+          }
+        : unknown);
+
+/**
+ * Takes the raw type of a remote object in the other thread and returns the type as it is visible to the local thread
+ * when proxied with `Runtime.apiProxy()`.
+ *
+ * This does not handle call signatures, which is handled by the more general `Remote<T>` type.
+ *
+ * @template T The raw type of a remote object as seen in the other thread.
+ */
+declare type RemoteObject<T> = {
+    [P in keyof T]: RemoteProperty<T[P]>;
+};
+
+/**
+ * Takes the raw type of a remote property and returns the type that is visible to the local thread on the proxy.
+ *
+ * Note: This needs to be its own type alias, otherwise it will not distribute over unions.
+ * See https://www.typescriptlang.org/docs/handbook/advanced-types.html#distributive-conditional-types
+ */
+declare type RemoteProperty<T> = T extends Function | ProxyMarked ? Remote<T> : Promisify<T>;
+
+/**
+ * The instance of Runtime this AddOn is running into.
+ * It contains methods to expose APIs from this runtime
+ * and getting access to APIs exposed by other runtimes.
+ */
+export declare class Runtime {
+    /**
+     * The runtime-type of this Runtime.
+     * Will always be "documentSandbox".
+     */
+    get type(): RuntimeType.documentSandbox;
+    /**
+     * Exposes the concrete object/function of type T,
+     * which can be accessed into different runtime part of this AddOn e.g., "panel" (iframe) runtime.
+     * Note that only concrete objects / class instances are supported. We can't expose entire class
+     * from one runtime and create instance of that class in another runtime. Trying to do
+     * so may result in undefined behaviour.
+     * @param obj - the concrete object to expose to other runtimes
+     * Note: This method call is allowed only once. Subsequent calls are ignored.
+     */
+    exposeApi<T>(obj: T): void;
+    /**
+     * Requests a promise based proxy object for other runtimes, which will be used
+     * by this document model sandbox to directly call the APIs exposed (using exposeApi) from the other runtimes (e.g., iframe UI runtime).
+     * await or .then is necessary, since returned object is a promise.
+     * @param runtimeType - the runtime, for which proxy object needs to be created.
+     * @returns a promise which may resolve to a proxy or reject with rejection reason.
+     * The promise resolves to API proxy object exposed by desired runtime, as soon as the other runtime is finished initializing.
+     * Note: Calling the method again for same runtime type will return a new proxy object without any behavior difference.
+     */
+    apiProxy<T>(runtimeType: RuntimeType): Promise<Remote<T>>;
+}
+
+/**
+ * Supported runtime types for this AddOn.
+ */
+export declare enum RuntimeType {
+    /**
+     * Represents iframe runtime part of this AddOn.
+     */
+    panel = "panel",
+    /**
+     * @deprecated Use 'documentSandbox' instead.
+     * Represents document model sandbox part of this AddOn.
+     */
+    script = "script",
+    /**
+     * Represents document model sandbox part of this AddOn.
+     */
+    documentSandbox = "documentSandbox"
+}
+
+/**
+ * Takes a type that may be Promise and unwraps the Promise type.
+ * If `P` is not a Promise, it returns `P`.
+ *
+ * This is the inverse of `Promisify<T>`.
+ */
+declare type Unpromisify<P> = P extends Promise<infer T> ? T : P;
+
+/**
+ * Inverse of `ProxyOrClone<T>`.
+ */
+declare type UnproxyOrClone<T> = T extends RemoteObject<ProxyMarked> ? Local<T> : T;
+
+export {};

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

@@ -25,21 +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;
+    constants: unknown;
 }
 
 declare interface ApiUtils {
@@ -76,21 +68,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;
 }
 
 /**
@@ -146,7 +130,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`.
      *
@@ -218,7 +202,7 @@ export declare interface ColorFill extends Fill {
     /**
      * The fill type.
      */
-    readonly type: FillTypeValue.color;
+    readonly type: FillType.color;
     /**
      * The fill color.
      */
@@ -232,7 +216,13 @@ export declare enum ColorSpace {
     sRGB = "sRGB"
 }
 
-export declare const Constants: typeof ApiConstants;
+/**
+ * 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
@@ -254,6 +244,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
@@ -343,14 +340,13 @@ export declare class Editor {
      * See {@link StrokeOptions} 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.
+     * - `dashPattern` has default value [] if none is provided. Array must be
+     *   of even length. Values cannot be negative.
      * - `dashOffset` has default value 0 if none is provided. This options 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.
+     * {@link StrokePosition.center} is supported.
      *
      * @returns a stroke configured with the given options.
      */
@@ -361,6 +357,42 @@ export declare class Editor {
      * 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;
@@ -411,7 +443,7 @@ export declare interface Fill {
     /**
      * The fill type.
      */
-    readonly type: FillTypeValue;
+    readonly type: FillType;
 }
 
 /**
@@ -428,7 +460,7 @@ export declare class FillableNode extends StrokableNode implements IFillableNode
  * <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,11 +473,31 @@ 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(): 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.
@@ -463,7 +515,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.
      */
@@ -523,17 +575,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 +615,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
@@ -663,29 +710,56 @@ declare class 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);
+    get type(): SceneNodeType;
+    /**
+     * 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 parent. Undefined if the node is an orphan, or if the node is the artwork root.
      */
@@ -704,11 +778,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 +787,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 +802,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
@@ -768,6 +838,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 +884,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 +976,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 +1013,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,14 +1029,33 @@ 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"
+}
+
+/**
+ * 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 SolidColorShapeNode extends Node {
+    /**
+     * The color of the single color shape.
+     */
+    get color(): Color | undefined;
+    set color(color: Color | undefined);
 }
 
 /**
  * Base class for a Node that can have its own stroke.
  */
 export declare class StrokableNode extends Node implements IStrokableNode {
-    static DEFAULT_STROKE_WIDTH: number;
     /**
      * Any stroke(s) on the shape. Use the methods on this ItemList object to get, add, and remove strokes.
      */
@@ -920,7 +1069,7 @@ export declare interface Stroke extends StrokeOptions {
     /**
      * The position of the stroke relative to the outline of the shape.
      */
-    readonly position: StrokePositionValue;
+    readonly position: StrokePosition;
 }
 
 /**
@@ -953,17 +1102,29 @@ 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 Node {
+    /**
+     * Stroke on the shape.
+     */
+    get stroke(): Stroke | undefined;
+    set stroke(stroke: Stroke | 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 TextAlignmentValue {
+declare enum TextAlignment {
     left = 1,
     right = 2,
     center = 3
@@ -981,10 +1142,15 @@ 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);
 }
 
+/**
+ * An UnknownNode is a node with limited support and therefore treated as a leaf node.
+ */
+export declare class UnknownNode extends Node {}
+
 export declare const utils: ApiUtils;
 
 export {};

package/{script → sandbox}/global.d.ts

@@ -23,8 +23,8 @@
  ********************************************************************************/
 
 /**
- * Here are various global objects and Web APIs available for use in script code.
- * Please note, script runtime exposes only a subset of functionalities
+ * Here are various global objects and Web APIs available for use in document sandbox code.
+ * Please note, document sandbox runtime exposes only a subset of functionalities
  * exposed by standard Web APIs.
  */
 declare global {
@@ -40,11 +40,6 @@ declare global {
         assert(assertion?: boolean, msg?: string, ...subst: any[]): void;
     }
 
-    function setTimeout(functionRef: Function, delay: number, ...params: any[]): number;
-    function clearTimeout(timeoutID: number): void;
-    function setInterval(functionRef: Function, delay: number, ...params: any[]): number;
-    function clearInterval(intervalID: number): void;
-
     interface Blob {
         readonly size: number;
         readonly type: string;
@@ -53,6 +48,10 @@ declare global {
         text(): Promise<string>;
     }
 
+    interface BlobPropertyBag {
+        type?: string;
+    }
+
     var Blob: {
         prototype: Blob;
         new (blobParts?: BlobPart[], options?: BlobPropertyBag): Blob;

package/{script → sandbox}/index.d.ts

@@ -22,7 +22,7 @@
  * SOFTWARE.
  ********************************************************************************/
 
-export * from "./express.js";
+export * from "./express-document-sdk.js";
 export * from "./global.js";
-export * from "./script-sdk.js";
-export { default } from "./script-sdk.js";
+export * from "./add-on-sdk-document-sandbox.js";
+export { default } from "./add-on-sdk-document-sandbox.js";

package/ui/ui-sdk.d.ts

@@ -22,8 +22,6 @@
  * SOFTWARE.
  ********************************************************************************/
 
-import { Remote } from "comlink";
-
 /**
  * Base interface for all type of add-ons
  */
@@ -134,7 +132,16 @@ export declare enum AppEvent {
     /**
      * triggered when drag is complete on the currently dragged element.
      */
-    dragend = "dragend"
+    dragend = "dragend",
+
+    /**
+     * triggered when the document id is available in the application.
+     */
+    documentIdAvailable = "documentIdAvailable",
+    /**
+     * triggered when the document title is changed in the application.
+     */
+    documentTitleChange = "documentTitleChange"
 }
 
 export declare type AppEventHandlerType<Event extends AppEventType> = (data: AppEventsTypeMap[Event]) => void;
@@ -147,6 +154,9 @@ declare interface AppEventsTypeMap {
     [AppEvent.localechange]: AppLocaleChangeEventData;
     [AppEvent.dragstart]: AppDragStartEventData;
     [AppEvent.dragend]: AppDragEndEventData;
+
+    [AppEvent.documentIdAvailable]: DocumentIdAvailableEventData;
+    [AppEvent.documentTitleChange]: DocumentTitleChangeEventData;
 }
 
 export declare type AppEventType = keyof AppEventsTypeMap & string;
@@ -552,9 +562,31 @@ declare interface Document_2 {
      * Create renditions
      */
     createRenditions(renditionOptions: RenditionOptions, renditionIntent?: RenditionIntent): Promise<Rendition[]>;
+    /**
+     * Get document id
+     */
+    id(): Promise<string | undefined>;
+    /**
+     * Get document name/title
+     */
+    title(): Promise<string>;
 }
 export { Document_2 as Document };
 
+/**
+ * The payload data sent to the document id available event handler.
+ */
+declare interface DocumentIdAvailableEventData {
+    documentId: string | undefined;
+}
+
+/**
+ * The payload data sent to the document title change event handler.
+ */
+declare interface DocumentTitleChangeEventData {
+    documentTitle: string;
+}
+
 /**
  * Interface to hold various callbacks which are required to be passed to enableDragToDocument.
  */
@@ -673,11 +705,64 @@ export declare interface JpgRenditionOptions extends RenditionOptions {
     };
 }
 
+/**
+ * Takes the raw type of a remote object or function as a remote thread would see it through a proxy (e.g. when
+ * passed in as a function argument) and returns the type the local thread has to supply.
+ * Creation of new class objects is not allowed.
+ *
+ * This is the inverse of `Remote<T>`. It takes a `Remote<T>` and returns its original input `T`.
+ */
+declare type Local<T> = LocalObject<T> &
+    (T extends (...args: infer TArguments) => infer TReturn
+        ? (
+              ...args: {
+                  [I in keyof TArguments]: ProxyOrClone<TArguments[I]>;
+              }
+          ) => MaybePromise<UnproxyOrClone<Unpromisify<TReturn>>>
+        : unknown) &
+    (T extends {
+        new (...args: infer TArguments): infer TInstance;
+    }
+        ? {
+              new: never;
+          }
+        : unknown);
+
 /**
  * Placeholder for future localization support
  */
 export declare type LocalizedString = string;
 
+/**
+ * Takes the type of an object as a remote thread would see it through a proxy (e.g. when passed in as a function
+ * argument) and returns the type that the local thread has to supply.
+ *
+ * This does not handle call signatures, which is handled by the more general `Local<T>` type.
+ *
+ * This is the inverse of `RemoteObject<T>`.
+ *
+ * @template T The type of a proxied object.
+ */
+declare type LocalObject<T> = {
+    [P in keyof T]: LocalProperty<T[P]>;
+};
+
+/**
+ * Takes the raw type of a property as a remote thread would see it through a proxy (e.g. when passed in as a function
+ * argument) and returns the type that the local thread has to supply.
+ *
+ * This is the inverse of `RemoteProperty<T>`.
+ *
+ * Note: This needs to be its own type alias, otherwise it will not distribute over unions. See
+ * https://www.typescriptlang.org/docs/handbook/advanced-types.html#distributive-conditional-types
+ */
+declare type LocalProperty<T> = T extends Function | ProxyMarked ? Local<T> : Unpromisify<T>;
+
+/**
+ * Expresses that a type can be either a sync or async.
+ */
+declare type MaybePromise<T> = Promise<T> | T;
+
 /**
  * Media Attributes for importing media
  */
@@ -738,6 +823,29 @@ export declare interface PngRenditionOptions extends RenditionOptions {
     };
 }
 
+/**
+ * Takes a type and wraps it in a Promise, if it not already is one.
+ * This is to avoid `Promise<Promise<T>>`.
+ *
+ * This is the inverse of `Unpromisify<T>`.
+ */
+declare type Promisify<T> = T extends Promise<unknown> ? T : Promise<T>;
+
+/**
+ * Interface of values that were marked to be proxied with `Runtime.apiProxy()`.
+ * Can also be implemented by classes.
+ */
+declare interface ProxyMarked {
+    [proxyMarker]: true;
+}
+
+declare const proxyMarker: unique symbol;
+
+/**
+ * Proxies `T` if it is a `ProxyMarked`, clones it otherwise (as handled by structured cloning and transfer handlers).
+ */
+declare type ProxyOrClone<T> = T extends ProxyMarked ? Remote<T> : T;
+
 /**
  * Rendition page range
  */
@@ -753,6 +861,47 @@ declare enum Range_2 {
 }
 export { Range_2 as Range };
 
+/**
+ * Takes the raw type of a remote object or function in the other thread and returns the type as it is visible to
+ * the local thread from the proxy return value of `Runtime.apiProxy()`.
+ * Creation of new class objects is not allowed.
+ */
+declare type Remote<T> = RemoteObject<T> &
+    (T extends (...args: infer TArguments) => infer TReturn
+        ? (
+              ...args: {
+                  [I in keyof TArguments]: UnproxyOrClone<TArguments[I]>;
+              }
+          ) => Promisify<ProxyOrClone<Unpromisify<TReturn>>>
+        : unknown) &
+    (T extends {
+        new (...args: infer TArguments): infer TInstance;
+    }
+        ? {
+              new: never;
+          }
+        : unknown);
+
+/**
+ * Takes the raw type of a remote object in the other thread and returns the type as it is visible to the local thread
+ * when proxied with `Runtime.apiProxy()`.
+ *
+ * This does not handle call signatures, which is handled by the more general `Remote<T>` type.
+ *
+ * @template T The raw type of a remote object as seen in the other thread.
+ */
+declare type RemoteObject<T> = {
+    [P in keyof T]: RemoteProperty<T[P]>;
+};
+
+/**
+ * Takes the raw type of a remote property and returns the type that is visible to the local thread on the proxy.
+ *
+ * Note: This needs to be its own type alias, otherwise it will not distribute over unions.
+ * See https://www.typescriptlang.org/docs/handbook/advanced-types.html#distributive-conditional-types
+ */
+declare type RemoteProperty<T> = T extends Function | ProxyMarked ? Remote<T> : Promisify<T>;
+
 export declare interface Rendition {
     /**
      * Type of Rendition
@@ -833,14 +982,15 @@ export declare interface Runtime {
     /**
      * @experimental - Experimental API
      * Exposes the concrete object/function of type T,
-     * which can be accessed into different runtime part of this AddOn e.g., "script" runtime.
+     * which can be accessed into different runtime part of this AddOn e.g., "document model sandbox" runtime.
      * Note that only concrete objects / class instances are supported. We can't expose entire class
      * from one runtime and create instance of that class in another runtime. Trying to do
      * so may result in undefined behaviour.
      * @param apiObj - the concrete object to expose to other runtimes
      *
      * Notes:
-     * 1. This method is only present if this is a panel runtime and it has an associated script runtime.
+     * 1. This method is only present if this UI runtime represents panel UI (not RuntimeType.dialog),
+     *    and the add-on has an associated document model sandbox. The sandbox runtime provides similar method to expose APIs in the other direction.
      * 2. This method call is allowed only once. Subsequent calls are ignored.
      */
     exposeApi?<T>(apiObj: T): void;
@@ -855,7 +1005,8 @@ export declare interface Runtime {
      * @see https://github.com/GoogleChromeLabs/comlink/blob/main/src/comlink.ts#L117
      *
      * Note:
-     * 1. This method is only present if this is a panel runtime and it has an associated script runtime.
+     * 1. This method is only present if this UI runtime represents panel UI (not RuntimeType.dialog),
+     *    and the add-on has an associated document model sandbox. The sandbox runtime provides similar method to get proxy object in the other direction.
      * 2. Calling the method again for same runtime type will return a new proxy object without any behavior difference.
      */
     apiProxy?<T>(runtimeType: RuntimeType): Promise<Remote<T>>;
@@ -871,9 +1022,14 @@ export declare enum RuntimeType {
      */
     dialog = "dialog",
     /**
-     * Add-On's script runtime - js runtime that hosts the add-ons script / document authoring logic.
+     * @deprecated Use `documentSandbox` instead.
+     * Add-On's document model sandbox - JS runtime that hosts add-on code that has direct access to the full model.
      */
-    script = "script"
+    script = "script",
+    /**
+     * Add-On's document model sandbox - JS runtime that hosts add-on code that has direct access to the full model.
+     */
+    documentSandbox = "documentSandbox"
 }
 
 export declare type SimpleDialogOptions = AlertDialogOptions | InputDialogOptions;
@@ -898,6 +1054,19 @@ export declare interface UI {
 
 declare type UiTheme = "light" | "dark" | "lightest" | "darkest";
 
+/**
+ * Takes a type that may be Promise and unwraps the Promise type.
+ * If `P` is not a Promise, it returns `P`.
+ *
+ * This is the inverse of `Promisify<T>`.
+ */
+declare type Unpromisify<P> = P extends Promise<infer T> ? T : P;
+
+/**
+ * Inverse of `ProxyOrClone<T>`.
+ */
+declare type UnproxyOrClone<T> = T extends RemoteObject<ProxyMarked> ? Local<T> : T;
+
 /**
  * Types of dialog variants supported.
  */

package/script/script-sdk.d.ts

@@ -1,101 +0,0 @@
-/********************************************************************************
- * MIT License
-
- * © Copyright 2023 Adobe. All rights reserved.
-
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- ********************************************************************************/
-
-import { Remote } from "comlink";
-
-/**
- * Represents the instance of this AddOn.
- * The instance contains the necessary details like the associated Runtime etc.
- */
-export declare class AddOn {
-    /**
-     * Get the runtime instance, which represents
-     * the execution environment for this AddOn.
-     */
-    get runtime(): Runtime;
-}
-
-/**
- * The APIs provided by AddOn Script SDK.
- * The APIs are exposed as an ES6 module.
- */
-export declare class AddOnScriptSDK {
-    /**
-     * Returns the instance of this AddOn.
-     * @see AddOn
-     */
-    get instance(): AddOn;
-}
-
-declare const addOnScriptSdk: AddOnScriptSDK;
-export default addOnScriptSdk;
-
-/**
- * The instance of Runtime this AddOn is running into.
- * It contains methods to expose APIs from this runtime
- * and getting access to APIs exposed by other runtimes.
- */
-export declare class Runtime {
-    /**
-     * The runtime-type of this Runtime.
-     * Will always be "script".
-     */
-    get type(): RuntimeType.script;
-    /**
-     * Exposes the concrete object/function of type T,
-     * which can be accessed into different runtime part of this AddOn e.g., "panel" (iframe) runtime.
-     * Note that only concrete objects / class instances are supported. We can't expose entire class
-     * from one runtime and create instance of that class in another runtime. Trying to do
-     * so may result in undefined behaviour.
-     * @param obj - the concrete object to expose to other runtimes
-     * Note: This method call is allowed only once. Subsequent calls are ignored.
-     */
-    exposeApi<T>(obj: T): void;
-    /**
-     * Requests a promise based proxy object for other runtimes, which will be used
-     * by this script runtime to directly call the APIs exposed (using exposeApi) from the other runtimes (e.g., UI runtime).
-     * await or .then is necessary, since returned object is a promise.
-     * @param runtimeType - the runtime, for which proxy object needs to be created.
-     * @returns a promise which may resolve to a proxy or reject with rejection reason.
-     * The promise resolves to API proxy object exposed by desired runtime, as soon as the other runtime is finished initializing.
-     * Note: Calling the method again for same runtime type will return a new proxy object without any behavior difference.
-     */
-    apiProxy(runtimeType: RuntimeType): Promise<Remote<unknown>>;
-}
-
-/**
- * Supported runtime types for this AddOn.
- */
-export declare enum RuntimeType {
-    /**
-     * Represents iframe runtime part of this AddOn.
-     */
-    panel = "panel",
-    /**
-     * Represents Script runtime part of this AddOn.
-     */
-    script = "script"
-}
-
-export {};