lucid-extension-sdk 0.0.6 → 0.0.13

package/sdk/data/datasourceproxy.d.ts

@@ -1,6 +1,6 @@
 import { JsonSerializable } from '../core/jsonserializable';
-import { ElementProxy } from '../document/elementproxy';
 import { MapProxy } from '../document/mapproxy';
+import { PropertyStoreProxy } from '../document/propertystoreproxy';
 import { EditorClient } from '../editorclient';
 import { CollectionProxy } from './collectionproxy';
 import { SchemaDefinition } from './schemadefinition';
@@ -8,7 +8,7 @@ import { SchemaDefinition } from './schemadefinition';
  * A data source represents a set of related data collections on a document. Typically one data source
  * is produced for each data import.
  */
-export declare class DataSourceProxy extends ElementProxy {
+export declare class DataSourceProxy extends PropertyStoreProxy {
     readonly id: string;
     /**
      * @param id ID of the collection on the current document
@@ -21,9 +21,15 @@ export declare class DataSourceProxy extends ElementProxy {
      * the collection ID on other documents if the same data is imported there.
      */
     readonly collections: MapProxy<string, CollectionProxy>;
+    /**
+     * Create a new collection as part of this data source.
+     * @param name
+     * @param schema
+     * @returns The newly created collection
+     */
     addCollection(name: string, schema: SchemaDefinition): CollectionProxy;
     /**
-     * @returns a human-readable name for this data source
+     * @returns A human-readable name for this data source
      */
     getName(): string;
     /**

package/sdk/data/datasourceproxy.js

@@ -3,14 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataSourceProxy = void 0;
 const checks_1 = require("../core/checks");
 const fieldtypedefinition_1 = require("../core/data/fieldtypedefinition/fieldtypedefinition");
-const elementproxy_1 = require("../document/elementproxy");
 const mapproxy_1 = require("../document/mapproxy");
+const propertystoreproxy_1 = require("../document/propertystoreproxy");
 const collectionproxy_1 = require("./collectionproxy");
 /**
  * A data source represents a set of related data collections on a document. Typically one data source
  * is produced for each data import.
  */
-class DataSourceProxy extends elementproxy_1.ElementProxy {
+class DataSourceProxy extends propertystoreproxy_1.PropertyStoreProxy {
     /**
      * @param id ID of the collection on the current document
      * @param client
@@ -25,6 +25,12 @@ class DataSourceProxy extends elementproxy_1.ElementProxy {
          */
         this.collections = new mapproxy_1.MapProxy(() => this.client.sendCommand("lc" /* ListCollections */, { 'id': this.id }), (id) => new collectionproxy_1.CollectionProxy(id, this.client));
     }
+    /**
+     * Create a new collection as part of this data source.
+     * @param name
+     * @param schema
+     * @returns The newly created collection
+     */
     addCollection(name, schema) {
         return new collectionproxy_1.CollectionProxy(this.client.sendCommand("cc" /* CreateCollection */, {
             's': this.id,
@@ -34,7 +40,7 @@ class DataSourceProxy extends elementproxy_1.ElementProxy {
         }), this.client);
     }
     /**
-     * @returns a human-readable name for this data source
+     * @returns A human-readable name for this data source
      */
     getName() {
         return this.properties.get('Name');

package/sdk/data/referencekeydefinition.d.ts

@@ -1,17 +1,45 @@
 import { SerializedReferenceKeyType } from '../core/data/referencekeys/serializedreferencekey';
 import { SerializedFieldType } from '../core/data/serializedfield/serializedfields';
 import { SchemaDefinition } from './schemadefinition';
+/**
+ * A reference key that points to a [DataItem](#classes_data_dataitemproxy-DataItemProxy) in a
+ * [Collection](#classes_data_collectionproxy-CollectionProxy). This is the most common type of
+ * reference key to create.
+ *
+ * For more information, see the [Developer Guide](/extension-api#guide-reference-keys).
+ */
 export interface CollectionReferenceKeyDefinition {
+    /** The ID of the collection referenced */
     collectionId: string;
+    /** The [primary key](#classes_data_dataitemproxy-DataItemProxy_primarykey) of the data item referenced */
     primaryKey: string;
-    fieldWhitelist?: string[];
+    /** If true, prevent the user from editing the field values of this reference key through the normal UI */
     readonly?: boolean;
+    /**
+     * If specified, only expose this list of fields through this reference key. This can be used to limit
+     * namespace pollution in shape data from lots of unnecessary fields, or just to hide information you'd
+     * prefer not to be visible in the UI or through formulas.
+     */
+    fieldWhitelist?: string[];
 }
+/**
+ * A reference key that has the field values embedded directly in the reference definition. This can be
+ * useful in cases when you want to have a standard schema of data associated with an element but do not
+ * for whatever reason want to construct an actual [Collection](#classes_data_collectionproxy-CollectionProxy)
+ * to house that data.
+ */
 export interface FlattenedReferenceDefinition {
-    name: string;
+    /** Name to display to the user for the reference key (what would normally be the collection name) */
+    name?: string;
+    /** Schema of the data stored at this key */
     schema: SchemaDefinition;
+    /** Field values available at this reference key */
     data: Record<string, SerializedFieldType>;
 }
 export declare type ReferenceKeyDefinition = CollectionReferenceKeyDefinition | FlattenedReferenceDefinition;
+/** @ignore */
 export declare function isCollectionReferenceKeyDefinition(def: ReferenceKeyDefinition): def is CollectionReferenceKeyDefinition;
+/** @ignore */
 export declare function serializeReferenceKeyDefinition(def: ReferenceKeyDefinition): SerializedReferenceKeyType;
+/** @ignore */
+export declare function parseReferenceKeyDefinition(def: SerializedReferenceKeyType): ReferenceKeyDefinition;

package/sdk/data/referencekeydefinition.js

@@ -1,12 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.serializeReferenceKeyDefinition = exports.isCollectionReferenceKeyDefinition = void 0;
+exports.parseReferenceKeyDefinition = exports.serializeReferenceKeyDefinition = exports.isCollectionReferenceKeyDefinition = void 0;
 const checks_1 = require("../core/checks");
+const serializedreferencekey_1 = require("../core/data/referencekeys/serializedreferencekey");
 const schemadefinition_1 = require("./schemadefinition");
+/** @ignore */
 function isCollectionReferenceKeyDefinition(def) {
     return (0, checks_1.isString)(def.collectionId);
 }
 exports.isCollectionReferenceKeyDefinition = isCollectionReferenceKeyDefinition;
+/** @ignore */
 function serializeReferenceKeyDefinition(def) {
     if (isCollectionReferenceKeyDefinition(def)) {
         return {
@@ -25,3 +28,25 @@ function serializeReferenceKeyDefinition(def) {
     }
 }
 exports.serializeReferenceKeyDefinition = serializeReferenceKeyDefinition;
+/** @ignore */
+function parseReferenceKeyDefinition(def) {
+    if ((0, serializedreferencekey_1.isTypedSerializedFlattenedReference)(def)) {
+        return {
+            schema: (0, schemadefinition_1.parseSchemaDefinition)(def['sc']),
+            name: def['n'],
+            data: def['d'],
+        };
+    }
+    else if ((0, serializedreferencekey_1.isUnTypedSerializedFlattenedReference)(def)) {
+        throw new Error('Untyped serialized flattened references not implemented');
+    }
+    else {
+        return {
+            collectionId: def['cid'],
+            primaryKey: def['pk'],
+            fieldWhitelist: def['wl'],
+            readonly: def['ro'],
+        };
+    }
+}
+exports.parseReferenceKeyDefinition = parseReferenceKeyDefinition;

package/sdk/data/referencekeyproxy.d.ts

@@ -6,4 +6,8 @@ export declare class ReferenceKeyProxy {
     private readonly client;
     private readonly settings;
     constructor(elementId: string | undefined, key: string | number, client: EditorClient, settings: SerializedReferenceKeyType);
+    get collectionId(): string | undefined;
+    get primaryKey(): string | undefined;
+    get definition(): import("./referencekeydefinition").ReferenceKeyDefinition;
+    getItem(): import("./dataitemproxy").DataItemProxy;
 }

package/sdk/data/referencekeyproxy.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReferenceKeyProxy = void 0;
+const serializedreferencekey_1 = require("../core/data/referencekeys/serializedreferencekey");
+const collectionproxy_1 = require("./collectionproxy");
+const referencekeydefinition_1 = require("./referencekeydefinition");
 class ReferenceKeyProxy {
     constructor(elementId, key, client, settings) {
         this.elementId = elementId;
@@ -8,5 +11,27 @@ class ReferenceKeyProxy {
         this.client = client;
         this.settings = settings;
     }
+    get collectionId() {
+        if ((0, serializedreferencekey_1.isSerializedFlattenedReference)(this.settings)) {
+            return undefined;
+        }
+        return this.settings['cid'];
+    }
+    get primaryKey() {
+        if ((0, serializedreferencekey_1.isSerializedFlattenedReference)(this.settings)) {
+            return undefined;
+        }
+        return this.settings['pk'];
+    }
+    get definition() {
+        return (0, referencekeydefinition_1.parseReferenceKeyDefinition)(this.settings);
+    }
+    getItem() {
+        const collectionId = this.collectionId;
+        if ((0, serializedreferencekey_1.isSerializedFlattenedReference)(this.settings) || !collectionId) {
+            throw new Error('Not implemented for flattened references');
+        }
+        return new collectionproxy_1.CollectionProxy(collectionId, this.client).items.get(this.settings['pk']);
+    }
 }
 exports.ReferenceKeyProxy = ReferenceKeyProxy;

package/sdk/data/schemadefinition.d.ts

@@ -1,11 +1,24 @@
 import { FieldTypeDefinition } from '../core/data/fieldtypedefinition/fieldtypedefinition';
 import { SerializedSchema } from '../core/data/serializedfield/serializedschema';
+/**
+ * The definition for a field to be included in a [SchemaDefinition](#interfaces_data_schemadefinition-SchemaDefinition)
+ */
 export interface FieldDefinition {
     name: string;
     type: FieldTypeDefinition;
 }
+/**
+ * Definition of a schema for creating a [Collection](#classes_data_collectionproxy-CollectionProxy)
+ */
 export interface SchemaDefinition {
     fields: FieldDefinition[];
+    /**
+     * Field names that are used to construct primary keys for new data items.
+     * Typically this contains only one field name, and that field is usually unique.
+     */
     primaryKey: string[];
 }
+/** @ignore */
 export declare function serializeSchemaDefinition(def: SchemaDefinition): SerializedSchema;
+/** @ignore */
+export declare function parseSchemaDefinition(def: SerializedSchema): SchemaDefinition;

package/sdk/data/schemadefinition.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.serializeSchemaDefinition = void 0;
+exports.parseSchemaDefinition = exports.serializeSchemaDefinition = void 0;
 const fieldtypedefinition_1 = require("../core/data/fieldtypedefinition/fieldtypedefinition");
+/** @ignore */
 function serializeSchemaDefinition(def) {
     return {
         'Fields': def.fields.map((field) => ({
@@ -12,3 +13,14 @@ function serializeSchemaDefinition(def) {
     };
 }
 exports.serializeSchemaDefinition = serializeSchemaDefinition;
+/** @ignore */
+function parseSchemaDefinition(def) {
+    return {
+        fields: def['Fields'].map((field) => ({
+            name: field['Name'],
+            type: (0, fieldtypedefinition_1.deserializeFieldTypeDefinition)(field['Type']),
+        })),
+        primaryKey: def['PrimaryKey'],
+    };
+}
+exports.parseSchemaDefinition = parseSchemaDefinition;

package/sdk/document/blockclasses/blockproxyregistry.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.findProxyClass = void 0;
+const customblockproxy_1 = require("./customblockproxy");
 const erdblockproxy_1 = require("./erdblockproxy");
-const allProxyClasses = [erdblockproxy_1.ERDBlockProxy];
+const allProxyClasses = [erdblockproxy_1.ERDBlockProxy, customblockproxy_1.CustomBlockProxy];
 function findProxyClass(className) {
     return allProxyClasses.find((proxy) => proxy.classNameRegex.test(className));
 }

package/sdk/document/blockclasses/customblockproxy.d.ts

@@ -0,0 +1,6 @@
+import { BlockProxy } from '../blockproxy';
+export declare class CustomBlockProxy extends BlockProxy {
+    static classNameRegex: RegExp;
+    isFromStencil(library: string, shape: string): boolean;
+    getStencilTextAreaName(stencilTextAreaName: string): string | undefined;
+}

package/sdk/document/blockclasses/customblockproxy.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomBlockProxy = void 0;
+const checks_1 = require("../../core/checks");
+const blockproxy_1 = require("../blockproxy");
+class CustomBlockProxy extends blockproxy_1.BlockProxy {
+    isFromStencil(library, shape) {
+        const stencil = this.properties.get('Stencil');
+        if ((0, checks_1.isObject)(stencil)) {
+            const sourceStencil = this.client.sendCommand("gp" /* GetProperty */, { 'p': 'Stencil-' + stencil['id'] });
+            if ((0, checks_1.isObject)(sourceStencil) && (0, checks_1.isObject)(sourceStencil['sourcePackage'])) {
+                return (sourceStencil['sourcePackage']['packageId'] === lucid.getPackageId() &&
+                    sourceStencil['sourcePackage']['library'] === library &&
+                    sourceStencil['sourcePackage']['shape'] === shape);
+            }
+        }
+        return false;
+    }
+    getStencilTextAreaName(stencilTextAreaName) {
+        return this.textAreas.keys().find((name) => name.endsWith('_' + stencilTextAreaName));
+    }
+}
+exports.CustomBlockProxy = CustomBlockProxy;
+CustomBlockProxy.classNameRegex = /^CustomBlock$/;

package/sdk/document/blockdefinition.d.ts

@@ -13,12 +13,14 @@ export interface BlockDefinition {
      */
     boundingBox: Box;
     /**
-     * Additional properties to set on the block immediately after creation
+     * Additional properties to set on the block immediately after creation. This is not typically
+     * set directly (it's easier and safer to call `.properties.set()` after block creation) but
+     * is set by [EditorClient.getCustomShapeDefinition](#classes_editorclient-EditorClient_getcustomshapedefinition).
      */
     properties?: JsonObject;
     /**
      * If specified, the stencil to use for a custom shape. This is not typically set directly; use
-     * PageProxy.getCustomShapeDefinition().
+     * [EditorClient.getCustomShapeDefinition](#classes_editorclient-EditorClient_getcustomshapedefinition).
      */
     stencil?: JsonSerializable;
 }

package/sdk/document/blockproxy.d.ts

@@ -1,18 +1,34 @@
 import { ItemProxy } from './itemproxy';
 /**
- * A block is a single shape on the document.
+ * A block is a single shape on the document. A BlockProxy provides an interface to
+ * read and write the content of an existing block, and is typically accessed through
+ * [PageProxy.blocks](#classes_document_pageproxy-PageProxy_blocks) or another
+ * similar mechanism.
  */
 export declare class BlockProxy extends ItemProxy {
     /**
-     * @returns the type of block this is
+     * @returns The class name of this block. This name is not necessarily human-readable,
+     * and will remain consistent over time, e.g. "ProcessBlock"..
      */
     getClassName(): string;
     /**
-     * @returns The amount this block is rotated around its own center, in radians
+     * @returns The amount this block is rotated around its own center, in radians.
      */
     getRotation(): number;
     /**
-     * @returns an array of lines that have one or both endpoints connected to this block
+     * @returns An array of lines that have one or both endpoints connected to this block.
      */
     getConnectedLines(): import("./lineproxy").LineProxy[];
+    /**
+     * Link a text area to a data field, so that editing the text area will also update the
+     * associated data, and vice versa.
+     *
+     * To use this, first establish a reference key on this block with
+     * [setReferenceKey](/extension-sdk/#classes_document_blockproxy-BlockProxy_setreferencekey).
+     *
+     * @param textAreaKey
+     * @param referenceKey
+     * @param field
+     */
+    linkText(textAreaKey: string, referenceKey: string | number, field: string): void;
 }

package/sdk/document/blockproxy.js

@@ -3,27 +3,54 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BlockProxy = void 0;
 const itemproxy_1 = require("./itemproxy");
 /**
- * A block is a single shape on the document.
+ * A block is a single shape on the document. A BlockProxy provides an interface to
+ * read and write the content of an existing block, and is typically accessed through
+ * [PageProxy.blocks](#classes_document_pageproxy-PageProxy_blocks) or another
+ * similar mechanism.
  */
 class BlockProxy extends itemproxy_1.ItemProxy {
     /**
-     * @returns the type of block this is
+     * @returns The class name of this block. This name is not necessarily human-readable,
+     * and will remain consistent over time, e.g. "ProcessBlock"..
      */
     getClassName() {
         return this.properties.get('ClassName');
     }
     /**
-     * @returns The amount this block is rotated around its own center, in radians
+     * @returns The amount this block is rotated around its own center, in radians.
      */
     getRotation() {
         return this.properties.get('Rotation');
     }
     /**
-     * @returns an array of lines that have one or both endpoints connected to this block
+     * @returns An array of lines that have one or both endpoints connected to this block.
      */
     getConnectedLines() {
         const ids = this.client.sendCommand("gcl" /* GetConnectedLines */, this.id);
         return ids.map((id) => this.client.getLineProxy(id));
     }
+    /**
+     * Link a text area to a data field, so that editing the text area will also update the
+     * associated data, and vice versa.
+     *
+     * To use this, first establish a reference key on this block with
+     * [setReferenceKey](/extension-sdk/#classes_document_blockproxy-BlockProxy_setreferencekey).
+     *
+     * @param textAreaKey
+     * @param referenceKey
+     * @param field
+     */
+    linkText(textAreaKey, referenceKey, field) {
+        if (!this.textAreas.keys().includes(textAreaKey)) {
+            throw new Error('Invalid text area key');
+        }
+        if (!this.referenceKeys.keys().includes(referenceKey)) {
+            throw new Error('Invalid reference key');
+        }
+        this.properties.set(textAreaKey + '_Link', {
+            'ref': referenceKey,
+            'f': field,
+        });
+    }
 }
 exports.BlockProxy = BlockProxy;

package/sdk/document/documentproxy.d.ts

@@ -1,5 +1,6 @@
 import { EditorClient } from '../editorclient';
 import { ElementProxy } from './elementproxy';
+import { ItemProxy } from './itemproxy';
 import { MapProxy } from './mapproxy';
 import { PageDefinition } from './pagedefinition';
 import { PageProxy } from './pageproxy';
@@ -7,6 +8,8 @@ import { PageProxy } from './pageproxy';
  * The currently-open Lucid document
  */
 export declare class DocumentProxy extends ElementProxy {
+    private static nextHookId;
+    private static getNextHookName;
     /**
      * The set of pages on this document, organized by ID
      */
@@ -15,7 +18,7 @@ export declare class DocumentProxy extends ElementProxy {
     /**
      * Add a new page to the current document
      * @param def Definition of the page to add
-     * @returns the created page
+     * @returns The created page
      */
     addPage(def: PageDefinition): PageProxy;
     /**
@@ -24,7 +27,24 @@ export declare class DocumentProxy extends ElementProxy {
      */
     setTitle(title: string): void;
     /**
-     * @returns the title of this document
+     * @returns The title of this document
      */
     getTitle(): string;
+    /**
+     * Watch for new blocks, lines, or groups added to this document. The callback will
+     * be called with new items created by the current user, but will not be called with items
+     * created
+     *
+     *  - As part of a generated diagram, e.g. org chart
+     *  - As a result of undo or redo
+     *  - By another user on the same document
+     *
+     * @param callback
+     * @returns A handle that can be passed to `unhookCreateItems`
+     */
+    hookCreateItems(callback: (items: ItemProxy[]) => void): string;
+    /**
+     * @param handle Return value from `hookCreateItems`
+     */
+    unhookCreateItems(handle: string): void;
 }

package/sdk/document/documentproxy.js

@@ -15,10 +15,13 @@ class DocumentProxy extends elementproxy_1.ElementProxy {
          */
         this.pages = new mapproxy_1.MapProxy(() => this.client.sendCommand("lp" /* ListPages */, undefined), (pageId) => new pageproxy_1.PageProxy(pageId, this.client));
     }
+    static getNextHookName() {
+        return '__documentproxy__hook' + DocumentProxy.nextHookId++;
+    }
     /**
      * Add a new page to the current document
      * @param def Definition of the page to add
-     * @returns the created page
+     * @returns The created page
      */
     addPage(def) {
         const id = this.client.sendCommand("cp" /* CreatePage */, undefined);
@@ -34,10 +37,38 @@ class DocumentProxy extends elementproxy_1.ElementProxy {
         this.properties.set('Title', title);
     }
     /**
-     * @returns the title of this document
+     * @returns The title of this document
      */
     getTitle() {
         return this.properties.get('Title');
     }
+    /**
+     * Watch for new blocks, lines, or groups added to this document. The callback will
+     * be called with new items created by the current user, but will not be called with items
+     * created
+     *
+     *  - As part of a generated diagram, e.g. org chart
+     *  - As a result of undo or redo
+     *  - By another user on the same document
+     *
+     * @param callback
+     * @returns A handle that can be passed to `unhookCreateItems`
+     */
+    hookCreateItems(callback) {
+        const actionName = DocumentProxy.getNextHookName();
+        this.client.registerAction(actionName, (msg) => {
+            callback(msg['ids'].map((id) => this.client.getItemProxy(id)));
+        });
+        this.client.sendCommand("hci" /* HookCreateItems */, { 'n': actionName });
+        return actionName;
+    }
+    /**
+     * @param handle Return value from `hookCreateItems`
+     */
+    unhookCreateItems(handle) {
+        this.client.deleteAction(handle);
+        this.client.sendCommand("uci" /* UnhookCreateItems */, { 'n': handle });
+    }
 }
 exports.DocumentProxy = DocumentProxy;
+DocumentProxy.nextHookId = 0;

package/sdk/document/elementproxy.d.ts

@@ -1,25 +1,18 @@
 import { ReferenceKeyDefinition } from '../data/referencekeydefinition';
 import { ReferenceKeyProxy } from '../data/referencekeyproxy';
 import { EditorClient } from '../editorclient';
-import { MapProxy, WriteableMapProxy } from './mapproxy';
+import { MapProxy } from './mapproxy';
+import { PropertyStoreProxy } from './propertystoreproxy';
 import { ShapeDataProxy } from './shapedataproxy';
 /**
  * An element is anything on a Lucid document that can have properties and shape data:
- *  * The document itself
- *  * Pages
- *  * Blocks
- *  * Lines
- *  * Groups
+ *  * [The document itself](#classes_document_documentproxy-DocumentProxy)
+ *  * [Pages](#classes_document_pageproxy-PageProxy)
+ *  * [Blocks](#classes_document_blockproxy-BlockProxy)
+ *  * [Lines](#classes_document_lineproxy-LineProxy)
+ *  * [Groups](#classes_document_groupproxy-GroupProxy)
  */
-export declare class ElementProxy {
-    readonly id: string | undefined;
-    protected readonly client: EditorClient;
-    /**
-     * All properties available on this element, organized by name.
-     * Not all properties are writeable (e.g. "ClassName" on a block).
-     * To move or resize elements, use setLocation() or setBoundingBox() or offset() instead.
-     */
-    readonly properties: WriteableMapProxy<string, import("..").JsonSerializable>;
+export declare class ElementProxy extends PropertyStoreProxy {
     /**
      * The shape data set directly on this element (not including any shape data inherited from the page or a containing group).
      */
@@ -29,23 +22,38 @@ export declare class ElementProxy {
      * This collection is read-only.
      */
     readonly allShapeData: MapProxy<string, import("..").SerializedFieldType | import("..").DataError>;
+    /**
+     * The set of reference keys, organized by their ID, which can be either a string or number.
+     *
+     * For more information, see the [Developer Guide](/extension-api#guide-reference-keys).
+     */
     readonly referenceKeys: MapProxy<string | number, ReferenceKeyProxy>;
+    /**
+     * Set a reference key on this element, replacing any existing reference at the specified key.
+     *
+     * @param key
+     * @param settings
+     */
     setReferenceKey(key: number | string, settings: ReferenceKeyDefinition): void;
+    /**
+     * Remove the specified reference key from this element.
+     * @param key
+     */
     removeReferenceKey(key: number | string): void;
     /**
      *
-     * @param id ID of this element, or undefined for the document itself
+     * @param id ID of this element, or `undefined` for the document itself
      * @param client
      */
     constructor(id: string | undefined, client: EditorClient);
     /**
-     * @returns true if this element still exists on the document, or false otherwise
+     * @returns `true` if this element still exists on the document, or `false` otherwise
      */
     exists(): boolean;
     /**
      * Execute a formula in the context of this element
      * @param formula The formula text, e.g. "@a + @b" to add together the shape data values a and b.
-     * @returns the result of the formula, or an error.
+     * @returns The result of the formula, or an error.
      */
     executeFormula(formula: string): import("..").SerializedFieldType | import("..").DataError;
 }