@adobe/ccweb-add-on-sdk-types 1.9.1 → 1.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe/ccweb-add-on-sdk-types",
-  "version": "1.9.1",
+  "version": "1.11.0",
   "author": "Adobe",
   "license": "MIT",
   "description": "Type definitions for Adobe Creative Cloud Web Add-on SDK.",
@@ -39,7 +39,6 @@
   },
   "dependencies": {
     "tslib": "2.6.2",
-    "@swc/helpers": "0.5.12",
     "gl-matrix": "3.3.0"
   },
   "devDependencies": {

package/sandbox/express-document-sdk.d.ts

@@ -22,22 +22,125 @@
  * SOFTWARE.
  ********************************************************************************/
 
-/// <reference types="gl-matrix/index.js" />
-
 import { mat2d } from "gl-matrix";
 
+/**
+ * AddOnData class provides APIs to read, write, remove private metadata to a Node.
+ * This metadata is accessible only to the add-on that has set it.
+ */
+export declare class AddOnData {
+    /**
+     * <InlineAlert slots="text" variant="warning"/>
+     *
+     * **IMPORTANT:** This is currently ***experimental only*** and should not be used in any add-ons you will be distributing until it has been declared stable. To use it, you will first need to set the `experimentalApis` flag to `true` in the [`requirements`](../../../manifest/index.md#requirements) section of the `manifest.json`.
+     *
+     * @experimental
+     * Sets a private metadata entry on the node.
+     * @param key - The key for the private metadata entry.
+     * @param value - The value for the private metadata entry.
+     */
+    setItem(key: string, value: string): void;
+    /**
+     * <InlineAlert slots="text" variant="warning"/>
+     *
+     * **IMPORTANT:** This is currently ***experimental only*** and should not be used in any add-ons you will be distributing until it has been declared stable. To use it, you will first need to set the `experimentalApis` flag to `true` in the [`requirements`](../../../manifest/index.md#requirements) section of the `manifest.json`.
+     *
+     * @experimental
+     * Retrieves the private metadata value for the specified key on the node.
+     * @param key - The key of the private metadata entry to retrieve.
+     * @returns The value of the private metadata entry.
+     */
+    getItem(key: string): string | undefined;
+    /**
+     * <InlineAlert slots="text" variant="warning"/>
+     *
+     * **IMPORTANT:** This is currently ***experimental only*** and should not be used in any add-ons you will be distributing until it has been declared stable. To use it, you will first need to set the `experimentalApis` flag to `true` in the [`requirements`](../../../manifest/index.md#requirements) section of the `manifest.json`.
+     *
+     * @experimental
+     * Removes a single private metadata entry on the node.
+     * @param key - The key of the private metadata entry to remove.
+     */
+    removeItem(key: string): void;
+    /**
+     * <InlineAlert slots="text" variant="warning"/>
+     *
+     * **IMPORTANT:** This is currently ***experimental only*** and should not be used in any add-ons you will be distributing until it has been declared stable. To use it, you will first need to set the `experimentalApis` flag to `true` in the [`requirements`](../../../manifest/index.md#requirements) section of the `manifest.json`.
+     *
+     * @experimental
+     * Clears all private metadata entries on the node.
+     */
+    clear(): void;
+    /**
+     * <InlineAlert slots="text" variant="warning"/>
+     *
+     * **IMPORTANT:** This is currently ***experimental only*** and should not be used in any add-ons you will be distributing until it has been declared stable. To use it, you will first need to set the `experimentalApis` flag to `true` in the [`requirements`](../../../manifest/index.md#requirements) section of the `manifest.json`.
+     *
+     * @experimental
+     * @returns an array of all keys for the private metadata entries on the node.
+     */
+    keys(): string[];
+    /**
+     * <InlineAlert slots="text" variant="warning"/>
+     *
+     * **IMPORTANT:** This is currently ***experimental only*** and should not be used in any add-ons you will be distributing until it has been declared stable. To use it, you will first need to set the `experimentalApis` flag to `true` in the [`requirements`](../../../manifest/index.md#requirements) section of the `manifest.json`.
+     *
+     * @experimental
+     * @returns an object with the remaining quota for private metadata on the node for this add-on.
+     * The object contains the following properties:
+     * - sizeInBytes: The remaining quota size in bytes (maximum 3KB).
+     * - numKeys: The remaining quota for the number of keys (maximum 20 keys).
+     */
+    get remainingQuota(): Readonly<{
+        sizeInBytes: number;
+        numKeys: number;
+    }>;
+    /**
+     * @returns an iterator for all the private metadata entries on the node.
+     * The iterator yields the metadata key-value pairs.
+     */
+    [Symbol.iterator](): Iterator<[string, string]>;
+}
+
 declare namespace ApiConstants {
-    export { ArrowHeadType, BlendMode, FillRule, FillType, SceneNodeType, StrokePosition, StrokeType, TextAlignment };
+    export {
+        ArrowHeadType,
+        BlendMode,
+        FillRule,
+        FillType,
+        SceneNodeType,
+        StrokePosition,
+        StrokeType,
+        TextAlignment,
+        TextType,
+        EditorEvent,
+        VisualEffectType
+    };
 }
 
 declare interface ApiModuleExport {
     editor: ExpressEditor;
     constants: unknown;
     colorUtils: ExpressColorUtils;
+    fonts: ExpressFonts;
+    viewport: ExpressViewport;
+}
+
+/**
+ * <InlineAlert slots="text" variant="warning"/>
+ *
+ * **IMPORTANT:** This is currently ***experimental only*** and should not be used in any add-ons you will be distributing until it has been declared stable. To use it, you will first need to set the `experimentalApis` flag to `true` in the [`requirements`](../../../manifest/index.md#requirements) section of the `manifest.json`.
+ *
+ * @experimental
+ */
+export declare interface AreaTextLayout {
+    type: TextType.area;
+    width: number;
+    height: number;
 }
 
 /**
  * <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 ArrowHeadType {
@@ -53,7 +156,7 @@ declare enum ArrowHeadType {
 
 /**
  * ArtboardList represents an ordered list of ArtboardNodes arranged in a timeline sequence, where they are called "scenes."
- * All items in the list are children of a single PageNode.
+ * All items in the list are children of a single {@link PageNode}.
  *
  * 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.
@@ -71,8 +174,12 @@ export declare class ArtboardList extends RestrictedItemList<ArtboardNode> {
 
 /**
  * An ArtboardNode represents an artboard object in the scenegraph. All user visual content must be contained on an artboard.
+ * Artboards are always contained on a {@link PageNode}; when a page contains multiple artboards, the artboards represent
+ * "scenes" in a linear timeline sequence.
  *
- * When multiple artboards exist on a page, the artboards represent "scenes" in a linear timeline sequence.
+ * To create new artboards, see {@link ArtboardList.addArtboard}.
+ *
+ * Please note that creating and deleting an artboard in a single frame will crash the editor.
  */
 export declare class ArtboardNode extends VisualNode implements IRectangularNode, ContainerNode {
     /**
@@ -107,6 +214,103 @@ export declare class ArtboardNode extends VisualNode implements IRectangularNode
     get height(): number;
 }
 
+/**
+ * <InlineAlert slots="text" variant="warning"/>
+ *
+ * **IMPORTANT:** This is currently ***experimental only*** and should not be used in any add-ons you will be distributing until it has been declared stable. To use it, you will first need to set the `experimentalApis` flag to `true` in the [`requirements`](../../../manifest/index.md#requirements) section of the `manifest.json`.
+ *
+ * @experimental
+ */
+export declare interface AutoHeightTextLayout {
+    type: TextType.autoHeight;
+    width: number;
+}
+
+/**
+ * Font the current user has access or licensing permissions to create / edit content with.
+ */
+export declare class AvailableFont extends BaseFont {
+    /**
+     * <InlineAlert slots="text" variant="warning"/>
+     *
+     * **IMPORTANT:** This is currently ***experimental only*** and should not be used in any add-ons you will be distributing until it has been declared stable. To use it, you will first need to set the `experimentalApis` flag to `true` in the [`requirements`](../../../manifest/index.md#requirements) section of the `manifest.json`.
+     *
+     * @experimental
+     * Whether the font is a premium Adobe font.
+     */
+    get isPremium(): boolean;
+    get availableForEditing(): true;
+}
+
+/**
+ * <InlineAlert slots="text" variant="warning"/>
+ *
+ * **IMPORTANT:** This is currently ***experimental only*** and should not be used in any add-ons you will be distributing until it has been declared stable. To use it, you will first need to set the `experimentalApis` flag to `true` in the [`requirements`](../../../manifest/index.md#requirements) section of the `manifest.json`.
+ *
+ * @experimental
+ * Base character styles that can be applied to any range of characters.
+ * Excludes font style, which differs between the getter-oriented {@link CharacterStyles} interface and the
+ * setter-oriented {@link CharacterStylesInput}.
+ */
+declare interface BaseCharacterStyles {
+    /**
+     * Size of the text in points.
+     */
+    fontSize: number;
+    /**
+     * Text color.
+     */
+    color: Color;
+    /**
+     * Uniformly adjusts the letter spacing, aka character spacing. Specified as a delta relative to the font's default
+     * spacing, in units of 1/1000 em: positive values increase the spacing, negative values tighten the spacing, and 0
+     * leaves spacing at its default.
+     */
+    letterSpacing: number;
+    /**
+     * Adds an underline to text.
+     */
+    underline: boolean;
+}
+
+/**
+ * Represents a font that is able to be rendered within this document. However, the user may not have edit permissions for
+ * all such fonts.
+ */
+declare abstract class BaseFont {
+    /**
+     * <InlineAlert slots="text" variant="warning"/>
+     *
+     * **IMPORTANT:** This is currently ***experimental only*** and should not be used in any add-ons you will be distributing until it has been declared stable. To use it, you will first need to set the `experimentalApis` flag to `true` in the [`requirements`](../../../manifest/index.md#requirements) section of the `manifest.json`.
+     *
+     * @experimental
+     * The PostScript name of the font.
+     */
+    get postscriptName(): string;
+    /**
+     * <InlineAlert slots="text" variant="warning"/>
+     *
+     * **IMPORTANT:** This is currently ***experimental only*** and should not be used in any add-ons you will be distributing until it has been declared stable. To use it, you will first need to set the `experimentalApis` flag to `true` in the [`requirements`](../../../manifest/index.md#requirements) section of the `manifest.json`.
+     *
+     * @experimental
+     * The font family containing the font.
+     */
+    get family(): string;
+    /**
+     * <InlineAlert slots="text" variant="warning"/>
+     *
+     * **IMPORTANT:** This is currently ***experimental only*** and should not be used in any add-ons you will be distributing until it has been declared stable. To use it, you will first need to set the `experimentalApis` flag to `true` in the [`requirements`](../../../manifest/index.md#requirements) section of the `manifest.json`.
+     *
+     * @experimental
+     * The style of the font within the family.
+     */
+    get style(): string;
+    /**
+     * Whether the current user has permission to create / edit content using this font.
+     */
+    abstract get availableForEditing(): boolean;
+}
+
 /**
  * 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).
@@ -114,6 +318,16 @@ export declare class ArtboardNode extends VisualNode implements IRectangularNode
  * properties.
  */
 export declare class BaseNode {
+    /**
+     * <InlineAlert slots="text" variant="warning"/>
+     *
+     * **IMPORTANT:** This is currently ***experimental only*** and should not be used in any add-ons you will be distributing until it has been declared stable. To use it, you will first need to set the `experimentalApis` flag to `true` in the [`requirements`](../../../manifest/index.md#requirements) section of the `manifest.json`.
+     *
+     * @experimental
+     * Get {@link AddOnData} reference for managing the private metadata on this node for this add-on.
+     */
+    get addOnData(): AddOnData;
+
     /**
      * A unique identifier for this node that stays the same when the file is closed & reopened, or if the node is
      * moved to a different part of the document.
@@ -170,6 +384,7 @@ export declare interface BitmapImage {
 
 /**
  * <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.
  *
  * Determines how a scenenode is composited on top of the content rendered below it.
@@ -212,6 +427,63 @@ declare enum BlendMode {
     luminosity = 17
 }
 
+/**
+ * <InlineAlert slots="text" variant="warning"/>
+ *
+ * **IMPORTANT:** This is currently ***experimental only*** and should not be used in any add-ons you will be distributing until it has been declared stable. To use it, you will first need to set the `experimentalApis` flag to `true` in the [`requirements`](../../../manifest/index.md#requirements) section of the `manifest.json`.
+ *
+ * @experimental
+ * Text styles that can be applied to any range of characters, even a short span like a single word. (Contrast with
+ * ParagraphStyles, which must be applied to an entire paragraph atomically).
+ */
+export declare interface CharacterStyles extends BaseCharacterStyles {
+    font: Font;
+}
+
+/**
+ * <InlineAlert slots="text" variant="warning"/>
+ *
+ * **IMPORTANT:** This is currently ***experimental only*** and should not be used in any add-ons you will be distributing until it has been declared stable. To use it, you will first need to set the `experimentalApis` flag to `true` in the [`requirements`](../../../manifest/index.md#requirements) section of the `manifest.json`.
+ *
+ * @experimental
+ * Variant of {@link CharacterStyles} with all style fields optional, used for applyCharacterStyles(). When using that API,
+ * any fields not specified are left unchanged, preserving the text's existing styles.
+ *
+ * If specified, the font must be of the {@link AvailableFont} type – one that is guaranteed to be available for the current
+ * user to edit with.
+ */
+export declare interface CharacterStylesInput extends Partial<BaseCharacterStyles> {
+    font?: AvailableFont;
+}
+
+/**
+ * <InlineAlert slots="text" variant="warning"/>
+ *
+ * **IMPORTANT:** This is currently ***experimental only*** and should not be used in any add-ons you will be distributing until it has been declared stable. To use it, you will first need to set the `experimentalApis` flag to `true` in the [`requirements`](../../../manifest/index.md#requirements) section of the `manifest.json`.
+ *
+ * @experimental
+ * A set of {@link CharacterStyles} along with the range of characters they apply to. Seen in the characterStyleRanges
+ * getter.
+ *
+ * Note that fonts returned by the getter are *not* guaranteed to be ones the user has rights to edit with, even though they
+ * are visible in the document.
+ */
+export declare interface CharacterStylesRange extends CharacterStyles, StyleRange {}
+
+/**
+ * <InlineAlert slots="text" variant="warning"/>
+ *
+ * **IMPORTANT:** This is currently ***experimental only*** and should not be used in any add-ons you will be distributing until it has been declared stable. To use it, you will first need to set the `experimentalApis` flag to `true` in the [`requirements`](../../../manifest/index.md#requirements) section of the `manifest.json`.
+ *
+ * @experimental
+ * Variant of {@link CharacterStylesRange} with all style fields optional, along with the range of characters they apply to.
+ * Used for the characterStyleRanges setter. When invoking the setter, any fields not specified are reset to their defaults.
+ *
+ * If specified, the font must be of the {@link AvailableFont} type – one that is guaranteed to be available for the current
+ * user to edit with.
+ */
+export declare interface CharacterStylesRangeInput extends CharacterStylesInput, StyleRange {}
+
 /**
  * Represents an RGBA color value.
  */
@@ -318,9 +590,13 @@ export declare class Context {
      */
     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).
+     * Sets the current selection to an array of {@link Node}.
+     * Accepts a single node as a shortcut for a length-1 array `[node]` or
+     * `undefined` as a shortcut for `[]`, which clears the selection.
+     *
+     * Only node(s) that meet the following criteria can be selected:
+     * - Nodes must be within the current artboard (nodes outside the active artboard are filtered out).
+     * - A node cannot be selected if its ancestor is also selected (descendants are filtered out).
      * - Locked nodes are filtered out (but will still be included in selectionIncludingNonEditable).
      */
     set selection(nodes: Node | readonly Node[] | undefined);
@@ -344,6 +620,32 @@ export declare class Context {
      * @returns The currently viewed page.
      */
     get currentPage(): PageNode;
+    /**
+     * <InlineAlert slots="text" variant="warning"/>
+     *
+     * **IMPORTANT:** This is currently ***experimental only*** and should not be used in any add-ons you will be distributing until it has been declared stable. To use it, you will first need to set the `experimentalApis` flag to `true` in the [`requirements`](../../../manifest/index.md#requirements) section of the `manifest.json`.
+     *
+     * @experimental
+     * Registers a handler for editor events such as selection change.
+     * The registered callback will be invoked when the specified event occurs.
+     * Note: Do not attempt to make changes to the document in response to a selection change callback because it may destabilize the application.
+     * @param eventName - an editor event name.
+     * @param callback - a callback to be registered for an editor event.
+     * @returns a unique ID for the registered event handler.
+     */
+    on(eventName: EditorEvent, callback: EditorEventHandler): EventHandlerId;
+    /**
+     * <InlineAlert slots="text" variant="warning"/>
+     *
+     * **IMPORTANT:** This is currently ***experimental only*** and should not be used in any add-ons you will be distributing until it has been declared stable. To use it, you will first need to set the `experimentalApis` flag to `true` in the [`requirements`](../../../manifest/index.md#requirements) section of the `manifest.json`.
+     *
+     * @experimental
+     * Unregisters handlers for editor events like selection change.
+     * @param eventName - an editor event name.
+     * @param handlerId - a unique ID returned by `editor.context.on` API.
+     * Callback that was previously registered will be removed and will no more be invoked when the event occurs.
+     */
+    off(eventName: EditorEvent, handlerId: EventHandlerId): void;
 }
 
 /**
@@ -364,7 +666,7 @@ export declare class Editor {
      * 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
+     * ```js
      * // 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.
@@ -427,7 +729,7 @@ export declare class Editor {
      * render as a gray placeholder on other clients until it has been uploaded to DCX and then downloaded by those clients.
      * This local client will act as having unsaved changes until the upload has finished.
      *
-     * @param bitmapData - BitmapImage resource (e.g. returned from loadBitmapImage()).
+     * @param bitmapData - BitmapImage resource (e.g. returned from {@link loadBitmapImage}).
      * @param options - Additional configuration:
      *      - initialSize - Size the image is displayed at. Must have the same aspect ratio as bitmapData. Defaults to the
      *        size the image would be created at by a UI drag-drop gesture (typically the image's full size, but scaled down
@@ -473,8 +775,11 @@ export declare class Editor {
     makeStroke(options?: Partial<SolidColorStroke>): SolidColorStroke;
     /**
      * @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
+     * invisible until its `fullContent` property's `text` is set. Creates point text, so the node's width will automatically
      * adjust to accommodate whatever text is set.
+     *
+     * Note: the registration point of this text node is not guaranteed to be at the top-left of the bounding box of its
+     * insertion parent. Recommend using `setPositionInParent` over `translation` to set the position.
      */
     createText(): TextNode;
     /**
@@ -490,7 +795,31 @@ export declare class Editor {
 export declare const editor: ExpressEditor;
 
 /**
- * An EllipseNode represents an ellipse object in the scenegraph.
+ * <InlineAlert slots="text" variant="warning"/>
+ *
+ * **IMPORTANT:** This is currently ***experimental only*** and should not be used in any add-ons you will be distributing until it has been declared stable. To use it, you will first need to set the `experimentalApis` flag to `true` in the [`requirements`](../../../manifest/index.md#requirements) section of the `manifest.json`.
+ *
+ * @experimental
+ * This enum represents the supported editor events.
+ */
+export declare enum EditorEvent {
+    selectionChange = "selectionChange"
+}
+
+/**
+ * <InlineAlert slots="text" variant="warning"/>
+ *
+ * **IMPORTANT:** This is currently ***experimental only*** and should not be used in any add-ons you will be distributing until it has been declared stable. To use it, you will first need to set the `experimentalApis` flag to `true` in the [`requirements`](../../../manifest/index.md#requirements) section of the `manifest.json`.
+ *
+ * @experimental
+ * This type represents function signature for the editor event handler callback.
+ */
+export declare type EditorEventHandler = () => void;
+
+/**
+ * An EllipseNode represents an ellipse or circle shape in the scenegraph.
+ *
+ * To create new ellipse, see {@link Editor.createEllipse}.
  */
 export declare class EllipseNode extends FillableNode {
     /**
@@ -513,6 +842,16 @@ export declare class EllipseNode extends FillableNode {
     set ry(value: number);
 }
 
+/**
+ * <InlineAlert slots="text" variant="warning"/>
+ *
+ * **IMPORTANT:** This is currently ***experimental only*** and should not be used in any add-ons you will be distributing until it has been declared stable. To use it, you will first need to set the `experimentalApis` flag to `true` in the [`requirements`](../../../manifest/index.md#requirements) section of the `manifest.json`.
+ *
+ * @experimental
+ * This type represents unique id of each event handler callback that is registered.
+ */
+export declare type EventHandlerId = string;
+
 declare const expressApiModule: ApiModuleExport;
 export default expressApiModule;
 
@@ -520,6 +859,8 @@ declare class ExpressColorUtils extends ColorUtils {}
 
 declare class ExpressEditor extends Editor {}
 
+declare class ExpressFonts extends Fonts {}
+
 /**
  * An ExpressRootNode represents the root node of the document's "scenegraph" artwork tree. The root contains a collection
  * of {@link pages}. Each page contains one or more artboards, arranged in a timeline sequence. All the visual content of
@@ -530,10 +871,13 @@ declare class ExpressEditor extends Editor {}
 export declare class ExpressRootNode extends BaseNode {
     /**
      * The pages of the document. All visual content is contained on artboards within the pages.
+     * To create new pages, see {@link PageList.addPage}.
      */
     get pages(): PageList;
 }
 
+declare class ExpressViewport extends Viewport {}
+
 /**
  * Base interface representing any fill in the scenegraph. See {@link FillableNode}.
  * Currently, you can only create {@link ColorFill}s, but you might encounter
@@ -559,6 +903,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.
  *
  * The fill rule, aka "winding rule," specifies how the interior area of a path is determined in cases where the path is
@@ -571,9 +916,11 @@ declare enum FillRule {
 
 /**
  * <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.
  *
  * <InlineAlert slots="text" variant="warning"/>
+ *
  * *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.
  */
@@ -582,11 +929,60 @@ declare enum FillType {
     color = "Color"
 }
 
+/**
+ * <InlineAlert slots="text" variant="warning"/>
+ *
+ * **IMPORTANT:** This is currently ***experimental only*** and should not be used in any add-ons you will be distributing until it has been declared stable. To use it, you will first need to set the `experimentalApis` flag to `true` in the [`requirements`](../../../manifest/index.md#requirements) section of the `manifest.json`.
+ *
+ * @experimental
+ * Represents a font in the document.
+ *
+ * Note: not every font encountered in the existing content is available for editing.
+ * Check the `availableForEditing` property to be sure.
+ */
+export declare type Font = AvailableFont | UnavailableFont;
+
+/**
+ * The Fonts class provides methods to work with fonts.
+ */
+export declare class Fonts {
+    /**
+     * <InlineAlert slots="text" variant="warning"/>
+     *
+     * **IMPORTANT:** This is currently ***experimental only*** and should not be used in any add-ons you will be distributing until it has been declared stable. To use it, you will first need to set the `experimentalApis` flag to `true` in the [`requirements`](../../../manifest/index.md#requirements) section of the `manifest.json`.
+     *
+     * @experimental
+     * Get an {@link AvailableFont} that exactly matches the given PostScript name, if any. Only fonts that the user has permission to use
+     * for editing content are returned, so the result of this call is always safe to apply to a {@link TextContentModel}'s styles.
+     *
+     * @param postscriptName - The PostScript name of the font.
+     * @returns The Font object if found and available for editing, otherwise undefined.
+     */
+    fromPostscriptName(postscriptName: string): Promise<AvailableFont | undefined>;
+}
+
+export declare const fonts: ExpressFonts;
+
+/**
+ * A GridCellNode represents the MediaContainerNode aspect of a grid cell. Unlike other MediaContainerNodes,
+ * GridCellNodes cannot be translated or rotated directly. This implementation translates and rotates the
+ * MediaRectangle child of the GridCellNode when those actions are applied.
+ */
+export declare class GridCellNode extends MediaContainerNode {}
+
 /**
  * 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.
+ *
+ * APIs to create a new grid layout are not yet available.
  */
 export declare class GridLayoutNode extends Node implements Readonly<IRectangularNode> {
+    /**
+     * The Grid's regular children. Does not include rectangles and skips over media constainer nodes to return fill grandchildren.
+     * Grid Cells are ordered by the y and then x position of their top left corner, i.e. left to right and top to bottom.
+     * The children cannot be added or removed.
+     */
+    get allChildren(): Readonly<Iterable<Node>>;
     /**
      * The background fill of the GridLayout.
      */
@@ -605,6 +1001,8 @@ export declare class GridLayoutNode extends Node implements Readonly<IRectangula
 /**
  * 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.
+ *
+ * To create new group, see {@link Editor.createGroup}.
  */
 export declare class GroupNode extends Node implements ContainerNode {
     /**
@@ -643,6 +1041,9 @@ declare interface IFillableNode {
  * ImageRectangleNode is a rectangular node that displays the image media part of a MediaContainerNode. It can only exist
  * within that container parent. Cropping can be adjusted by changing this media's position/rotation (as well as its mask
  * shape sibling node).
+ *
+ * ImageRectangleNodes cannot be created directly; use {@link Editor.createImageContainer} to create the entire
+ * container structure together.
  */
 export declare class ImageRectangleNode extends Node implements Readonly<IRectangularNode> {
     /**
@@ -688,6 +1089,8 @@ 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.
+     *
+     * @throws - if item has a different parent and item is a {@link TextNode} that's a part of a Text Flow, or if item's children subtree contains a TextNode who is a part of a Text Flow.
      */
     append(...items: T[]): void;
     /**
@@ -698,24 +1101,32 @@ export declare class ItemList<T extends ListItem> extends RestrictedItemList<T>
      * Replace `oldItem` with `newItem` in this list. Throws if `oldItem` is not a member of this list.
      * `newItem` is removed from its previous parent, if any – or if it's already in *this* list, its index is simply
      * changed. No-op if both arguments are the same item.
+     *
+     * @throws - if newItem has a different parent and newItem is a {@link TextNode} that's a part of a Text Flow, or if newItem's children subtree contains a TextNode who is a part of a Text Flow.
      */
     replace(oldItem: T, newItem: T): void;
     /**
      * Insert `newItem` so it is immediately before `before` in this list: places `newItem` at the index that `before` used
      * to occupy, shifting `before` and all later items to higher indices. `newItem` is removed from its previous parent,
      * if any – or if it's already in *this* list, its index is simply changed. No-op if both arguments are the same item.
+     *
+     * @throws - if newItem has a different parent and it is a {@link TextNode} that's a part of a Text Flow, or if newItem's children subtree contains a TextNode who is a part of a Text Flow.
      */
     insertBefore(newItem: T, before: T): void;
     /**
      * Insert `newItem` so it is immediately after `after` in this list: places `newItem` at the index one higher than `after`,
      * shifting all later items to higher indices (the index of `after` remains unchanged). `newItem` is removed from its previous parent,
      * if any – or if it's already in *this* list, its index is simply changed. No-op if both arguments are the same item.
+     *
+     * @throws - if newItem has a different parent and it is a {@link TextNode} that's a part of a Text Flow, or if newItem's children subtree contains a TextNode who is a part of a Text Flow.
      */
     insertAfter(newItem: T, after: T): void;
 }
 
 /**
- * A LineNode represents a simple line object in the scenegraph – a single straight-line segment.
+ * A LineNode represents a simple vector line in the scenegraph – a single straight-line segment.
+ *
+ * To create new lines, see {@link Editor.createLine}.
  */
 export declare class LineNode extends StrokableNode {
     static readonly DEFAULT_START_X = 0;
@@ -786,6 +1197,9 @@ export declare interface ListItem {}
  * A MediaContainerNode is a multi-node construct that displays media (such as images or video) with optional cropping and
  * clipping to a shape mask. The underlying media asset is always rectangular, but the final appearance of this node is
  * determined by the maskShape which is not necessarily a rectangle.
+ *
+ * To create new media container for a bitmap image, see {@link Editor.createImageContainer}. APIs for creating a
+ * container with other content, such as videos, are not yet available.
  */
 export declare class MediaContainerNode extends Node {
     /**
@@ -914,8 +1328,8 @@ export { Node as Node };
 
 /**
  * PageList represents an ordered list of PageNodes, all of which are children of the root node of the document's "scenegraph"
- * artwork tree. 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.
+ * artwork tree (see {@link ExpressRootNode}). 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.
  *
  * 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.
@@ -932,12 +1346,16 @@ export declare class PageList extends RestrictedItemList<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.
+ * A PageNode represents a page in the document, a child of the root node of the document's "scenegraph" artwork tree
+ * (see {@link ExpressRootNode}). 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.
+ *
+ * To create new pages, see {@link PageList.addPage}.
  */
 export declare class PageNode extends BaseNode implements Readonly<IRectangularNode> {
     /**
      * The artboards or "scenes" of a page, ordered by timeline sequence.
+     * To create new artboards, see {@link ArtboardList.addArtboard}.
      */
     get artboards(): ArtboardList;
     /**
@@ -967,8 +1385,10 @@ export declare class PageNode extends BaseNode implements Readonly<IRectangularN
 }
 
 /**
- * A PathNode represents a generic vector path shape in the scenegraph. Paths cannot be created or edited through this API
+ * A PathNode represents a generic vector path shape in the scenegraph. Paths cannot be edited through this API
  * yet, only read.
+ *
+ * To create new paths, see {@link Editor.createPath}.
  */
 export declare class PathNode extends FillableNode {
     /**
@@ -993,6 +1413,17 @@ export declare interface Point {
     y: number;
 }
 
+/**
+ * <InlineAlert slots="text" variant="warning"/>
+ *
+ * **IMPORTANT:** This is currently ***experimental only*** and should not be used in any add-ons you will be distributing until it has been declared stable. To use it, you will first need to set the `experimentalApis` flag to `true` in the [`requirements`](../../../manifest/index.md#requirements) section of the `manifest.json`.
+ *
+ * @experimental
+ */
+export declare interface PointTextLayout {
+    type: TextType.autoWidth;
+}
+
 /**
  * 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
@@ -1046,7 +1477,9 @@ export declare interface RectangleGeometry {
 }
 
 /**
- * A RectangleNode represents a rectangle object in the scenegraph.
+ * A RectangleNode represents a rectangle shape in the scenegraph.
+ *
+ * To create new rectangles, see {@link Editor.createRectangle}.
  */
 export declare class RectangleNode extends FillableNode implements IRectangularNode {
     /**
@@ -1144,9 +1577,11 @@ declare class RestrictedItemList<T extends ListItem> extends ReadOnlyItemList<T>
 
 /**
  * <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.
  *
  * <InlineAlert slots="text" variant="warning"/>
+ *
  * *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.
  */
@@ -1155,7 +1590,6 @@ declare enum SceneNodeType {
     rectangle = "Rectangle",
     ellipse = "Ellipse",
     path = "Path",
-    text = "Text",
     linkedAsset = "LinkedAsset",
     group = "Group",
     artboard = "ab:Artboard",
@@ -1173,8 +1607,12 @@ declare enum SceneNodeType {
     solidColorShape = "SolidColorShape",
     /** Type of StrokeShapeNode, representing a stroke-only prepackaged shape that appears as a leaf node in the UI */
     strokeShape = "StrokeShape",
+    /** Type of MediaContainerNode which is a child of a GridLayout, representing one of the Grid's cells*/
+    gridCell = "GridCell",
     /** 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"
+    gridLayout = "GridLayout",
+    /** Type of TextNode, representing a non-threaded text or a threaded text frame */
+    text = "Text"
 }
 
 /**
@@ -1255,6 +1693,7 @@ export declare interface Stroke {
 
 /**
  * <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.
  *
  * A stroke's {@link Stroke.position} determines how the thickness of the stroke is aligned along a shape's path outline.
@@ -1273,9 +1712,11 @@ export declare class StrokeShapeNode extends StrokableNode {}
 
 /**
  * <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.
  *
  * <InlineAlert slots="text" variant="warning"/>
+ *
  * *Additional stroke types may be added in the future.* If your code has different branches or cases depending on stroke type,
  * always have a default/fallback case to handle any unknown values you may encounter.
  */
@@ -1286,8 +1727,21 @@ declare enum StrokeType {
     color = "Color"
 }
 
+/**
+ * Represents a range of characters defined by a length (and implicitly started at the end of the previous range).
+ */
+declare interface StyleRange {
+    /**
+     * The length or number of characters in which character styles will be applied.
+     * Note: since characters are represented as UTF-16 code units, some symbols
+     * such as emojis are considered to have a length of 2.
+     */
+    length: number;
+}
+
 /**
  * <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 TextAlignment {
@@ -1297,22 +1751,193 @@ declare enum TextAlignment {
 }
 
 /**
- * A TextNode represents a text object in the scenegraph.
+ * Represents a complete piece of text content flow, which may be split across multiple {@link TextNode} frames for display.
+ * Use this model to get or modify the text string and the style ranges applied to it.
+ */
+export declare class TextContentModel {
+    /**
+     * <InlineAlert slots="text" variant="warning"/>
+     *
+     * **IMPORTANT:** This is currently ***experimental only*** and should not be used in any add-ons you will be distributing until it has been declared stable. To use it, you will first need to set the `experimentalApis` flag to `true` in the [`requirements`](../../../manifest/index.md#requirements) section of the `manifest.json`.
+     *
+     * @experimental
+     * A unique identifier for this node that stays the same when the file is closed & reopened, or if the node is
+     * moved to a different part of the document.
+     *
+     * To determine if two TextNodes are connected to the same TextContentModel,
+     * check if both models have the same id.
+     * Comparing two models using `===` will always fail.
+     */
+    get id(): string;
+    /**
+     * <InlineAlert slots="text" variant="warning"/>
+     *
+     * **IMPORTANT:** This is currently ***experimental only*** and should not be used in any add-ons you will be distributing until it has been declared stable. To use it, you will first need to set the `experimentalApis` flag to `true` in the [`requirements`](../../../manifest/index.md#requirements) section of the `manifest.json`.
+     *
+     * @experimental
+     * Get ordered list of all {@link TextNode}s that display this text content in the scenegraph. The text content
+     * starts in the first  {@link TextNode} "frame", and then flows into the second node once it has filled the first one. The ending of the
+     * text content may not be visible at all, if the last {@link TextNode} "frame" is not large enough to accommodate it.
+     *
+     * If there are multiple {@link TextNode}s, all of them must be configured to use {@link AreaTextLayout}.
+     */
+    get allTextNodes(): Readonly<Iterable<TextNode>>;
+    /**
+     * The complete text string, which may span multiple {@link TextNode} "frames" in the scenegraph.
+     */
+    get text(): string;
+    set text(textContent: string);
+    /**
+     * <InlineAlert slots="text" variant="warning"/>
+     *
+     * **IMPORTANT:** This is currently ***experimental only*** and should not be used in any add-ons you will be distributing until it has been declared stable. To use it, you will first need to set the `experimentalApis` flag to `true` in the [`requirements`](../../../manifest/index.md#requirements) section of the `manifest.json`.
+     *
+     * @experimental
+     * The character styles applied to different ranges of this text content. When setting character styles, any style
+     * properties that are not provided are reset to their defaults (contrast to {@link applyCharacterStyles} which
+     * preserves the text's existing styles for any fields not specified). When *getting* styles, all fields are always
+     * provided.
+     *
+     * Note: existing fonts used in the document, returned by this getter, are not guaranteed to be ones the current user
+     * has rights to edit with. The *setter* only accepts the AvailableFont type which has been verified to be usable.
+     */
+    get characterStyleRanges(): readonly CharacterStylesRange[];
+    set characterStyleRanges(styles: readonly CharacterStylesRangeInput[]);
+    /**
+     * <InlineAlert slots="text" variant="warning"/>
+     *
+     * **IMPORTANT:** This is currently ***experimental only*** and should not be used in any add-ons you will be distributing until it has been declared stable. To use it, you will first need to set the `experimentalApis` flag to `true` in the [`requirements`](../../../manifest/index.md#requirements) section of the `manifest.json`.
+     *
+     * @experimental
+     * Apply one or more styles to the characters in the given range, leaving any style properties that were not specified
+     * unchanged. Does not modify any styles in the text outside this range. Contrast to the {@link characterStyleRanges}
+     * setter, which specifies new style range(s) for the entire text at once, and resets any unspecified properties back to
+     * default styles.
+
+     * @param styles - The styles to apply.
+     * @param range - The start and length of character sequence to which the styles should be applied.
+     * If not specified the styles will be applied to the entire piece of text content flow.
+     */
+    applyCharacterStyles(
+        styles: CharacterStylesInput,
+        range?: {
+            start: number;
+            length: number;
+        }
+    ): void;
+}
+
+/**
+ * A TextNode represents a text display frame in the scenegraph. It may display an entire piece of text, or sometimes just
+ * a subset of longer text that flows across multiple TextNode "frames". Because of this, the TextNode does not directly hold
+ * the text content and styles – instead it refers to a {@link TextContentModel}, which may be shared across multiple TextNode frames.
+ *
+ * To create new a single-frame piece of text, see {@link Editor.createText}. APIs are not yet available to create
+ * multi-frame text flows.
  */
 export declare class TextNode extends Node {
     /**
-     * The text string of the node.
+     * The model containing the complete text string and its styles, only part of which may be visible within the bounds of
+     * this specific TextNode "frame." The full text content flow may be split across multiple frames, and/or it may be clipped if a
+     * fixed-size frame using {@link AreaTextLayout} does not fit all the (remaining) text.
+     *
+     * Note: When traversing the scenegraph in search of text content, bear in mind that multiple TextNodes may refer to the
+     * same single {@link TextContentModel}; this can give the impression that the same text is duplicated multiple times when it is
+     * not. Use {@link TextContentModel}.id to determine whether a given piece of text content is unique or if it's already been
+     * encountered before.
+     *
+     */
+    get fullContent(): TextContentModel;
+    /**
+     * <InlineAlert slots="text" variant="warning"/>
+     *
+     * **IMPORTANT:** This is currently ***experimental only*** and should not be used in any add-ons you will be distributing until it has been declared stable. To use it, you will first need to set the `experimentalApis` flag to `true` in the [`requirements`](../../../manifest/index.md#requirements) section of the `manifest.json`.
+     *
+     * @experimental
+     * The next TextNode that text overflowing this node will spill into, if any. If undefined and this TextNode is fixed size
+     * ({@link AreaTextLayout}), any text content that does not fit within this node's area will be clipped.
+     *
+     * To get *all* TextNodes that the text content may be split across, use `TextNode.fullContent.allTextNodes`.
+     */
+    get nextTextNode(): TextNode | undefined;
+    /**
+     * The text string content which is partially *or* fully displayed in this TextNode "frame."
+     * WARNING: If a piece of text content flows across several TextNodes, *each* TextNode's `text` getter will return
+     * the *entire* text content string.
+     * @deprecated - Use the text getter on {@link TextContentModel} instead. Access it via `TextNode.fullContent.text`.
      */
     get text(): string;
     /**
-     * Sets the text content of the text node.
+     * Sets the text content of the TextNode.
+     * WARNING: If a piece of text content flows across several TextNodes,
+     * *each* TextNode's `text` setter will sets the *entire* text content string.
+     * @deprecated - Use the text setter on {@link TextContentModel} instead. Access it via `TextNode.fullContent.text`.
      */
     set text(textContent: string);
     /**
-     * The horizontal text alignment of the text node. Alignment is always the same across this node's entire text content.
+     * The horizontal text alignment of the TextNode. Alignment is always the same across this node's entire text content.
      */
     get textAlignment(): TextAlignment;
     set textAlignment(alignment: TextAlignment);
+    /**
+     * <InlineAlert slots="text" variant="warning"/>
+     *
+     * **IMPORTANT:** This is currently ***experimental only*** and should not be used in any add-ons you will be distributing until it has been declared stable. To use it, you will first need to set the `experimentalApis` flag to `true` in the [`requirements`](../../../manifest/index.md#requirements) section of the `manifest.json`.
+     *
+     * @experimental
+     * @returns The list of visual effects applied to the TextNode.
+     */
+    get visualEffects(): readonly VisualEffectType[];
+    /**
+     * <InlineAlert slots="text" variant="warning"/>
+     *
+     * **IMPORTANT:** This is currently ***experimental only*** and should not be used in any add-ons you will be distributing until it has been declared stable. To use it, you will first need to set the `experimentalApis` flag to `true` in the [`requirements`](../../../manifest/index.md#requirements) section of the `manifest.json`.
+     *
+     * @experimental
+     * @returns The layout mode of the TextNode "frame."
+     */
+    get layout(): Readonly<PointTextLayout | AutoHeightTextLayout | AreaTextLayout | UnsupportedTextLayout>;
+    /**
+     * <InlineAlert slots="text" variant="warning"/>
+     *
+     * **IMPORTANT:** This is currently ***experimental only*** and should not be used in any add-ons you will be distributing until it has been declared stable. To use it, you will first need to set the `experimentalApis` flag to `true` in the [`requirements`](../../../manifest/index.md#requirements) section of the `manifest.json`.
+     *
+     * @experimental
+     * Sets the layout mode of the TextNode "frame."
+     *
+     * If this TextNode is part of a multi-frame text content flow, it must be configured to use {@link AreaTextLayout}. Other
+     * layout modes are only available for single-frame text.
+     *
+     * @throws if changing text layout to/from {@link TextType.magicFit} or {@link TextType.circular} layout when the text contains font(s) unavailable to the current user.
+     * @throws if TextNode is part of a multi-frame text content flow and the layout is not {@link AreaTextLayout}.
+     */
+    set layout(layout: PointTextLayout | AutoHeightTextLayout | AreaTextLayout);
+}
+
+/**
+ * <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 TextType {
+    /**
+     * Point text
+     */
+    autoWidth = 0,
+    /**
+     * Soft bottom
+     */
+    autoHeight = 1,
+    area = 2,
+    magicFit = 3,
+    circular = 4
+}
+
+/**
+ * Font the current user does not have access or licensing permissions to create / edit content with.
+ */
+export declare class UnavailableFont extends BaseFont {
+    get availableForEditing(): false;
 }
 
 /**
@@ -1320,6 +1945,54 @@ export declare class TextNode extends Node {
  */
 export declare class UnknownNode extends Node {}
 
+/**
+ * <InlineAlert slots="text" variant="warning"/>
+ *
+ * **IMPORTANT:** This is currently ***experimental only*** and should not be used in any add-ons you will be distributing until it has been declared stable. To use it, you will first need to set the `experimentalApis` flag to `true` in the [`requirements`](../../../manifest/index.md#requirements) section of the `manifest.json`.
+ *
+ * @experimental
+ */
+export declare interface UnsupportedTextLayout {
+    type: TextType.magicFit | TextType.circular;
+}
+
+/**
+ * Represents the area of the canvas that is currently visible on-screen.
+ */
+export declare class Viewport {
+    /**
+     * Adjusts the viewport to make the node's bounds visible on-screen, assuming all bounds are within the artboard bounds.
+     * Makes the node's {@link ArtboardNode} or {@link PageNode} visible if they were not already
+     * (which may result in {@link Context.selection} being cleared). It is strongly recomended
+     * to further draw user's attention to the node by setting it as the {@link Context.selection} following this call.
+     *
+     * After this call, the value of {@link Context.insertionParent} will always be the node's containing {@link ArtboardNode}.
+     *
+     * Note that the node might still not appear visible if:
+     *   - Its animation settings make it invisible at the beginning of the {@link ArtboardNode} "scene".
+     *   - It is obscured underneath other artwork in the z-order.
+     *   - It is hidden by a {@link GroupNode}'s mask or similar cropping.
+     */
+    bringIntoView(node: VisualNode): void;
+}
+
+export declare const viewport: ExpressViewport;
+
+/**
+ * <InlineAlert slots="text" variant="warning"/>
+ *
+ * **IMPORTANT:** This is currently ***experimental only*** and should not be used in any add-ons you will be distributing until it has been declared stable. To use it, you will first need to set the `experimentalApis` flag to `true` in the [`requirements`](../../../manifest/index.md#requirements) section of the `manifest.json`.
+ *
+ * @experimental
+ * Visual effects that can be applied to a text node.
+ */
+declare enum VisualEffectType {
+    generativeTextEffects = "GenerativeTextEffects",
+    outline = "Outline",
+    shadow = "Shadow",
+    shapeDecoration = "ShapeDecoration"
+}
+
 /**
  * A "node" represents an object in the scenegraph, the document's visual content tree. This class represents any node
  * that can be visually perceived in the content. Most visual content is a subclass of the richer Node class which extends

package/ui/ui-sdk.d.ts

@@ -259,7 +259,6 @@ declare interface ApplicationBase {
      */
     startPremiumUpgradeIfFreeUser(): Promise<boolean>;
     /**
-     * @experimental - Experimental API
      * Get information regarding current platform.
      * @returns the details regarding the current platform.
      */
@@ -372,9 +371,34 @@ export declare enum AuthorizationStatus {
     POPUP_BLOCKED = "POPUP_BLOCKED",
     POPUP_CLOSED = "POPUP_CLOSED",
     POPUP_TIMEOUT = "POPUP_TIMEOUT",
-    FAILED = "FAILED"
+    FAILED = "FAILED",
+    IFRAME_LOAD_FAILED = "IFRAME_LOAD_FAILED"
 }
 
+/**
+ * Request parameters to authorize a user using OAuth 2.0 PKCE based authorization in an iframe.
+ */
+export declare type AuthorizeInsideIframeRequest = AuthorizationRequest & {
+    /**
+     * Relative position of the oauth iframe panel
+     */
+    position?: {
+        top: number;
+        left: number;
+    };
+    /**
+     * Offset from the right and bottom of the Iframe container when the size (windowSize) is not specified.
+     */
+    offset?: {
+        right: number;
+        bottom: number;
+    };
+    /**
+     * Flag to determine if the iframe panel needs to show a header.
+     */
+    showHeader?: boolean;
+};
+
 /**
  * Request parameters to initiate an OAuth 2.0 PKCE based authorization workflow,
  * where the Add-on developer is responsible for handling redirect to his/her owned Redirect URL.
@@ -519,7 +543,6 @@ declare namespace Constants {
 export { Constants };
 
 /**
- * @experimental - Experimental API
  * Interface for the current platform
  */
 export declare interface CurrentPlatformPayload {
@@ -599,7 +622,6 @@ export declare interface DevFlags {
 }
 
 /**
- * @experimental - Experimental API
  * Denotes the device class
  */
 export declare enum DeviceClass {
@@ -683,9 +705,13 @@ export declare type DisableDragToDocument = () => void;
  */
 declare interface Document_2 {
     /**
-     * Add image/gif/Ps/Ai files to the current page
+     * Add image/Ps/Ai files to the current page
      */
     addImage(blob: Blob, attributes?: MediaAttributes): Promise<void>;
+    /**
+     * Add GIF files to the current page
+     */
+    addAnimatedImage(blob: Blob, attributes?: MediaAttributes): Promise<void>;
     /**
      * Add video to the current page
      */
@@ -711,6 +737,14 @@ declare interface Document_2 {
      * Get document name/title
      */
     title(): Promise<string>;
+    /**
+     * Import a Pdf to the document.
+     */
+    importPdf(blob: Blob, attributes: MediaAttributes): void;
+    /**
+     * Import a presentation to the document.
+     */
+    importPresentation(blob: Blob, attributes: MediaAttributes): void;
 }
 export { Document_2 as Document };
 
@@ -1064,6 +1098,12 @@ export declare interface OAuth {
      * @returns - {@link AuthorizationResult} Authorization result.
      */
     authorizeWithOwnRedirect(request: AuthorizeWithOwnRedirectRequest): Promise<AuthorizationResult>;
+    /**
+     * Authorize a user using OAuth 2.0 PKCE workflow in an iframe.
+     * @param request - {@link AuthorizeInsideIframeRequest} Payload with parameters to be used in the authorization workflow.
+     * @returns - {@link AuthorizationResponse} Response containing a ONE-TIME Authorization Code which can be used to obtain an access token.
+     */
+    authorizeInsideIframe(request: AuthorizeInsideIframeRequest): Promise<AuthorizationResponse>;
 }
 
 /**
@@ -1231,7 +1271,6 @@ export declare interface PdfRenditionOptions extends RenditionOptions {
 }
 
 /**
- * @experimental - Experimental API
  * Denotes the enum for current environment
  */
 export declare enum PlatformEnvironment {
@@ -1246,7 +1285,6 @@ export declare enum PlatformEnvironment {
 }
 
 /**
- * @experimental - Experimental API
  * Denotes the type of platform
  */
 export declare enum PlatformType {