lucid-extension-sdk 1.1.3 → 1.2.0

package/commandtypes.d.ts

@@ -20,7 +20,7 @@ import { PanelLocation } from './ui/panel';
  * Typically, an extension author will not need to access any of these commands directly, as they are all
  * exposed through appropriate classes and methods elsewhere in this SDK.
  *
- * To use these directly, use [EditorClient.sendCommand](#classes_editorclient-EditorClient_sendcommand).
+ * To use these directly, use {@link EditorClient.sendCommand}.
  *
  * FOR DEVELOPERS AT LUCID:
  * Follow this guide to add new commands: https://lucidatlassian.atlassian.net/wiki/x/3AA3Xww
@@ -174,7 +174,7 @@ export type CommandName = (typeof CommandName)[keyof typeof CommandName];
 export declare const commandTitles: Map<CommandName, string>;
 /**
  * This is a type declaration whose purpose is to allow TypeScript to enforce the correct parameter and
- * return types from [EditorClient.sendCommand](#classes_editorclient-EditorClient_sendcommand) based on
+ * return types from {@link EditorClient.sendCommand} based on
  * which command name you pass in as the first parameter.
  *
  * IMPORTANT - Before you add a new command bring it up in #api-committee to get feedback
@@ -1139,6 +1139,8 @@ export type AddSpreadsheetIntegrationQuery = {
     'dm'?: DependencyMappingSettings | undefined;
     /** Auto-sync configuration (only honored when `c` / addCardsIntegration is true) */
     'as'?: AutoSyncSettings | undefined;
+    /** Get default config action */
+    'gdc'?: string | undefined;
 };
 /** @ignore until spreadsheet integration is ready for launch (CHART-51946) */
 export type AddSpreadsheetIntegrationResult = undefined;
@@ -1634,7 +1636,19 @@ export type GetOAuthClientIdResult = Promise<string | undefined>;
 export type GetPropertyQuery = {
     /** ID of the LucidElement to read a property from, or undefined to read from the LucidDocument */
     'id'?: string | undefined;
-    /** Name of the property to read */
+    /**
+     * Name of the property to read.
+     *
+     * For text area properties, this returns the plain text string by default. To get rich text
+     * (text + inline markup such as bold, italic, links, and line spacing), prefix the text area
+     * name with `Rich:`. For example, `properties.get('Rich:Text')` returns an object with the
+     * structure `{t: string, m: Array}` where `t` is the text content and `m` is an array of
+     * markup entries. Each markup entry has:
+     * - `s` (number): start index
+     * - `e` (number, optional): end index (omitted for block-level markup)
+     * - `n` (string): markup name (e.g. `'b'` for bold, `'i'` for italic, `'lk'` for link, `'p'` for line spacing)
+     * - `v` (any): markup value
+     */
     'p': string;
 };
 export type GetPropertyResult = UnsafeJsonSerializableOrUndefined;
@@ -1984,7 +1998,19 @@ export type SetPropertyQuery = {
     'id'?: string | undefined;
     /** Name of the property to change */
     'p': string;
-    /** New value of the property */
+    /**
+     * New value of the property.
+     *
+     * For text area properties, you can pass a plain text string to set the text while preserving
+     * the existing style. To set rich text with inline markup (bold, italic, links, line spacing, etc.),
+     * prefix the text area name in `p` with `Rich:` (e.g. `p: 'Rich:Text'`) and pass an object as
+     * the value with the structure `{t: string, m: Array}` where `t` is the text content and `m`
+     * is an array of markup entries. Each markup entry has:
+     * - `s` (number): start index
+     * - `e` (number, optional): end index
+     * - `n` (string): markup name (e.g. `'b'` for bold, `'i'` for italic, `'lk'` for link, `'p'` for line spacing)
+     * - `v` (any): markup value
+     */
     'v'?: UnsafeJsonSerializableOrUndefined;
 };
 export type SetPropertyResult = undefined;

package/commandtypes.js

@@ -8,7 +8,7 @@ const checks_1 = require("./core/checks");
  * Typically, an extension author will not need to access any of these commands directly, as they are all
  * exposed through appropriate classes and methods elsewhere in this SDK.
  *
- * To use these directly, use [EditorClient.sendCommand](#classes_editorclient-EditorClient_sendcommand).
+ * To use these directly, use {@link EditorClient.sendCommand}.
  *
  * FOR DEVELOPERS AT LUCID:
  * Follow this guide to add new commands: https://lucidatlassian.atlassian.net/wiki/x/3AA3Xww

package/core/cardintegration/lucidcardintegrationregistry.d.ts

@@ -12,7 +12,10 @@ export declare class LucidCardIntegrationRegistry {
         name?: string | undefined;
         dataSourceId?: string | undefined;
     }) => Promise<ExtensionCardFieldOption[]>): string;
-    static registerUserSearchCallback(client: EditorClient, callback: (searchText: string, inputSoFar: Map<string, SerializedFieldType>) => Promise<ExtensionCardUserData[]>): string;
+    static registerUserSearchCallback(client: EditorClient, callback: (searchText: string, inputSoFar: Map<string, SerializedFieldType>, fieldData?: {
+        name?: string | undefined;
+        dataSourceId?: string | undefined;
+    }) => Promise<ExtensionCardUserData[]>): string;
     static registerFieldTypeToCollectionItemsCallback(client: EditorClient, callback: (fieldName: string, value: SerializedFieldType, dataSourceProxy?: DataSourceProxy | undefined) => Promise<[string, SerializedFields][]>): string;
     static registerFieldLabelIconsCallback(client: EditorClient, callback: (dataSourceProxy: DataSourceProxy, dataItemProxy: DataItemProxy) => Promise<ExtensionCardFieldLabelIcons>): string;
     static registerTagCallback(client: EditorClient, callback: TagCallback): string;

package/core/cardintegration/lucidcardintegrationregistry.js

@@ -28,31 +28,13 @@ class LucidCardIntegrationRegistry {
         return name;
     }
     static registerFieldSearchCallback(client, callback) {
-        const name = LucidCardIntegrationRegistry.nextHookName();
-        client.registerAction(name, async ({ 'i': inputSoFar, 's': searchText, 'fd': serializedFieldData }) => {
-            const fieldData = serializedFieldData
-                ? { name: serializedFieldData['n'], dataSourceId: serializedFieldData['ds'] }
-                : undefined;
-            const result = await callback(searchText, new Map(inputSoFar), fieldData);
-            return result.map((option) => (0, cardintegrationdefinitions_1.serializeCardFieldOption)(option));
-        });
-        return name;
+        return (0, sharedregistryutil_1.registerFieldSearchCallback)(client, callback, () => LucidCardIntegrationRegistry.nextHookName());
     }
     static registerUserSearchCallback(client, callback) {
-        const name = LucidCardIntegrationRegistry.nextHookName();
-        client.registerAction(name, async ({ 'i': inputSoFar, 's': searchText }) => {
-            const result = await callback(searchText, new Map(inputSoFar));
-            return result.map((userData) => (0, cardintegrationdefinitions_1.serializeCardUserData)(userData));
-        });
-        return name;
+        return (0, sharedregistryutil_1.registerUserSearchCallback)(client, callback, () => LucidCardIntegrationRegistry.nextHookName());
     }
     static registerFieldTypeToCollectionItemsCallback(client, callback) {
-        const name = LucidCardIntegrationRegistry.nextHookName();
-        client.registerAction(name, async ({ 'd': dataSourceId, 'v': value, 'f': fieldName }) => {
-            const dataSourceProxy = dataSourceId ? new datasourceproxy_1.DataSourceProxy(dataSourceId, client) : undefined;
-            return await callback(fieldName, value, dataSourceProxy);
-        });
-        return name;
+        return (0, sharedregistryutil_1.registerFieldTypeToCollectionItemsCallback)(client, callback, () => LucidCardIntegrationRegistry.nextHookName());
     }
     static registerFieldLabelIconsCallback(client, callback) {
         const name = LucidCardIntegrationRegistry.nextHookName();

package/core/lucidproduct.d.ts

@@ -4,6 +4,7 @@
 export declare const LucidProduct: {
     readonly Chart: "chart";
     readonly Spark: "spark";
+    /** @ignore */
     readonly TeamSpaces: "teamspaces";
 };
 export type LucidProduct = (typeof LucidProduct)[keyof typeof LucidProduct];

package/core/lucidproduct.js

@@ -7,5 +7,6 @@ exports.LucidProduct = void 0;
 exports.LucidProduct = {
     Chart: 'chart',
     Spark: 'spark',
+    /** @ignore */
     TeamSpaces: 'teamspaces',
 };

package/core/sharedcardintegration/sharedregistryutil.d.ts

@@ -1,7 +1,9 @@
 import { AutoSyncSettings, DependencyMappingSettings } from '../../commandtypes';
+import { DataSourceProxy } from '../../data/datasourceproxy';
 import { EditorClient } from '../../editorclient';
 import { type CardIntegrationAutoSyncConfig } from '../cardintegration/cardintegrationautosyncconfig';
-import { ImportResult, SearchResult } from './cardintegrationdefinitions';
+import { SerializedFieldType, SerializedFields } from '../data/serializedfield/serializedfields';
+import { ExtensionCardFieldOption, ExtensionCardUserData, ImportResult, SearchResult } from './cardintegrationdefinitions';
 import { CardIntegrationDependencyMappingConfig } from './dependencymappingconfig';
 /**
  * Serializes a `SearchResult` into the wire-format object the editor expects. Shared between the
@@ -48,3 +50,12 @@ export declare function serializeImportResults(result: ImportResult | ImportResu
  */
 export declare function registerAutoSync(client: EditorClient, autoSync: CardIntegrationAutoSyncConfig, getNextHookName: () => string): AutoSyncSettings;
 export declare function registerDependencyMapping(client: EditorClient, dependencyMapping: CardIntegrationDependencyMappingConfig, serialized: DependencyMappingSettings, getNextHookName: () => string): void;
+export declare function registerFieldSearchCallback(client: EditorClient, callback: (searchText: string, inputSoFar: Map<string, SerializedFieldType>, fieldData?: {
+    name?: string | undefined;
+    dataSourceId?: string | undefined;
+}) => Promise<ExtensionCardFieldOption[]>, getNextHookName: () => string): string;
+export declare function registerUserSearchCallback(client: EditorClient, callback: (searchText: string, inputSoFar: Map<string, SerializedFieldType>, fieldData?: {
+    name?: string | undefined;
+    dataSourceId?: string | undefined;
+}) => Promise<ExtensionCardUserData[]>, getNextHookName: () => string): string;
+export declare function registerFieldTypeToCollectionItemsCallback(client: EditorClient, callback: (fieldName: string, value: SerializedFieldType, dataSourceProxy?: DataSourceProxy | undefined) => Promise<[string, SerializedFields][]>, getNextHookName: () => string): string;

package/core/sharedcardintegration/sharedregistryutil.js

@@ -4,9 +4,13 @@ exports.serializeSearchResult = serializeSearchResult;
 exports.serializeImportResults = serializeImportResults;
 exports.registerAutoSync = registerAutoSync;
 exports.registerDependencyMapping = registerDependencyMapping;
+exports.registerFieldSearchCallback = registerFieldSearchCallback;
+exports.registerUserSearchCallback = registerUserSearchCallback;
+exports.registerFieldTypeToCollectionItemsCallback = registerFieldTypeToCollectionItemsCallback;
 const collectiondefinition_1 = require("../../data/collectiondefinition");
 const collectionproxy_1 = require("../../data/collectionproxy");
 const dataitemproxy_1 = require("../../data/dataitemproxy");
+const datasourceproxy_1 = require("../../data/datasourceproxy");
 const cardintegrationautosyncconfig_1 = require("../cardintegration/cardintegrationautosyncconfig");
 const checks_1 = require("../checks");
 const cardintegrationdefinitions_1 = require("./cardintegrationdefinitions");
@@ -297,3 +301,33 @@ function registerDependencyMapping(client, dependencyMapping, serialized, getNex
         });
     }
 }
+function registerFieldSearchCallback(client, callback, getNextHookName) {
+    const name = getNextHookName();
+    client.registerAction(name, async ({ 'i': inputSoFar, 's': searchText, 'fd': serializedFieldData }) => {
+        const fieldData = serializedFieldData
+            ? { name: serializedFieldData['n'], dataSourceId: serializedFieldData['ds'] }
+            : undefined;
+        const result = await callback(searchText, new Map(inputSoFar), fieldData);
+        return result.map((option) => (0, cardintegrationdefinitions_1.serializeCardFieldOption)(option));
+    });
+    return name;
+}
+function registerUserSearchCallback(client, callback, getNextHookName) {
+    const name = getNextHookName();
+    client.registerAction(name, async ({ 'i': inputSoFar, 's': searchText, 'fd': serializedFieldData }) => {
+        const fieldData = serializedFieldData
+            ? { name: serializedFieldData['n'], dataSourceId: serializedFieldData['ds'] }
+            : undefined;
+        const result = await callback(searchText, new Map(inputSoFar), fieldData);
+        return result.map((userData) => (0, cardintegrationdefinitions_1.serializeCardUserData)(userData));
+    });
+    return name;
+}
+function registerFieldTypeToCollectionItemsCallback(client, callback, getNextHookName) {
+    const name = getNextHookName();
+    client.registerAction(name, async ({ 'd': dataSourceId, 'v': value, 'f': fieldName }) => {
+        const dataSourceProxy = dataSourceId ? new datasourceproxy_1.DataSourceProxy(dataSourceId, client) : undefined;
+        return await callback(fieldName, value, dataSourceProxy);
+    });
+    return name;
+}

package/core/spreadsheetintegration/lucidspreadsheetintegration.d.ts

@@ -1,5 +1,7 @@
 import { CollectionProxy } from '../../data/collectionproxy';
+import type { DataSourceProxy } from '../../data/datasourceproxy';
 import type { CardIntegrationAutoSyncConfig } from '../cardintegration/cardintegrationautosyncconfig';
+import type { CardIntegrationConfig } from '../cardintegration/cardintegrationconfig';
 import { type SerializedUpstreamConfig } from '../data/datasource/serializedupstreamconfig';
 import type { SerializedFieldType } from '../data/serializedfield/serializedfields';
 import { type SerializedSchema } from '../data/serializedfield/serializedschema';
@@ -120,6 +122,12 @@ export declare abstract class LucidSpreadsheetIntegration {
     };
     fieldConfiguration?: Partial<ExtensionFieldConfiguration>;
     dependencyMapping?: CardIntegrationDependencyMappingConfig;
+    /**
+     * If specified, called when initializing the default card config for a newly imported spreadsheet.
+     * Use this to customize which fields appear in the detail edit panel.
+     * If not specified, all schema fields are included by default.
+     */
+    getDefaultConfig?: (dataSource: DataSourceProxy) => Promise<CardIntegrationConfig>;
     /**
      * If specified, allows the user to use auto-sync to keep generators populated from this spreadsheet integration.
      */

package/core/spreadsheetintegration/lucidspreadsheetintegrationregistry.d.ts

@@ -1,12 +1,16 @@
 import { DataSourceProxy } from '../../data/datasourceproxy';
 import { EditorClient } from '../../editorclient';
 import { SerializedFieldType, SerializedFields } from '../data/serializedfield/serializedfields';
-import { ExtensionCardUserData } from '../sharedcardintegration/cardintegrationdefinitions';
+import { ExtensionCardFieldOption, ExtensionCardUserData } from '../sharedcardintegration/cardintegrationdefinitions';
 import { LucidSpreadsheetIntegration } from './lucidspreadsheetintegration';
 /** @ignore until spreadsheet integration is ready for launch (CHART-51946) */
 export declare class LucidSpreadsheetIntegrationRegistry {
     private static nextHookId;
     private static nextHookName;
+    static registerFieldSearchCallback(client: EditorClient, callback: (searchText: string, inputSoFar: Map<string, SerializedFieldType>, fieldData?: {
+        name?: string | undefined;
+        dataSourceId?: string | undefined;
+    }) => Promise<ExtensionCardFieldOption[]>): string;
     static registerUserSearchCallback(client: EditorClient, callback: (searchText: string, inputSoFar: Map<string, SerializedFieldType>, fieldData?: {
         name?: string | undefined;
         dataSourceId?: string | undefined;

package/core/spreadsheetintegration/lucidspreadsheetintegrationregistry.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LucidSpreadsheetIntegrationRegistry = void 0;
 const commandtypes_1 = require("../../commandtypes");
 const datasourceproxy_1 = require("../../data/datasourceproxy");
+const cardintegrationconfig_1 = require("../cardintegration/cardintegrationconfig");
 const checks_1 = require("../checks");
 const cardintegrationdefinitions_1 = require("../sharedcardintegration/cardintegrationdefinitions");
 const sharedregistryutil_1 = require("../sharedcardintegration/sharedregistryutil");
@@ -12,24 +13,14 @@ class LucidSpreadsheetIntegrationRegistry {
     static nextHookName() {
         return '__lucidspreadsheet__hook' + LucidSpreadsheetIntegrationRegistry.nextHookId++;
     }
+    static registerFieldSearchCallback(client, callback) {
+        return (0, sharedregistryutil_1.registerFieldSearchCallback)(client, callback, () => LucidSpreadsheetIntegrationRegistry.nextHookName());
+    }
     static registerUserSearchCallback(client, callback) {
-        const name = LucidSpreadsheetIntegrationRegistry.nextHookName();
-        client.registerAction(name, async ({ 'i': inputSoFar, 's': searchText, 'fd': serializedFieldData }) => {
-            const fieldData = serializedFieldData
-                ? { name: serializedFieldData['n'], dataSourceId: serializedFieldData['ds'] }
-                : undefined;
-            const result = await callback(searchText, new Map(inputSoFar), fieldData);
-            return result.map((userData) => (0, cardintegrationdefinitions_1.serializeCardUserData)(userData));
-        });
-        return name;
+        return (0, sharedregistryutil_1.registerUserSearchCallback)(client, callback, () => LucidSpreadsheetIntegrationRegistry.nextHookName());
     }
     static registerFieldTypeToCollectionItemsCallback(client, callback) {
-        const name = LucidSpreadsheetIntegrationRegistry.nextHookName();
-        client.registerAction(name, async ({ 'd': dataSourceId, 'v': value, 'f': fieldName }) => {
-            const dataSourceProxy = dataSourceId ? new datasourceproxy_1.DataSourceProxy(dataSourceId, client) : undefined;
-            return await callback(fieldName, value, dataSourceProxy);
-        });
-        return name;
+        return (0, sharedregistryutil_1.registerFieldTypeToCollectionItemsCallback)(client, callback, () => LucidSpreadsheetIntegrationRegistry.nextHookName());
     }
     /**
      * Register a spreadsheet integration.
@@ -92,6 +83,15 @@ class LucidSpreadsheetIntegrationRegistry {
                 return fields;
             });
         }
+        let getDefaultConfigActionName = undefined;
+        if (spreadsheetIntegration.getDefaultConfig) {
+            getDefaultConfigActionName = LucidSpreadsheetIntegrationRegistry.nextHookName();
+            const getDefaultConfig = spreadsheetIntegration.getDefaultConfig;
+            client.registerAction(getDefaultConfigActionName, async (param) => {
+                const dataSource = new datasourceproxy_1.DataSourceProxy(param['d'], client);
+                return (0, cardintegrationconfig_1.serializeCardIntegrationConfig)(await getDefaultConfig(dataSource));
+            });
+        }
         const serialized = {
             'il': spreadsheetIntegration.itemLabel,
             'isl': spreadsheetIntegration.itemsLabel,
@@ -116,6 +116,9 @@ class LucidSpreadsheetIntegrationRegistry {
                 },
             },
         };
+        if (getDefaultConfigActionName) {
+            serialized['gdc'] = getDefaultConfigActionName;
+        }
         if (spreadsheetIntegration.iconConfiguration) {
             serialized['icu'] = {
                 'pi': spreadsheetIntegration.iconConfiguration.primaryIconUrl,

package/core/validators/validators.d.ts

@@ -198,6 +198,7 @@ export declare const isStringOrNegativeOne: (x: unknown) => x is string | -1;
 export declare const isRestrictions: (subject: unknown) => subject is DestructureGuardedTypeObj<{
     b: (x: unknown) => x is boolean | null | undefined;
     p: (x: unknown) => x is boolean | null | undefined;
+    s: (x: unknown) => x is boolean | null | undefined;
     c: (x: unknown) => x is boolean | null | undefined;
     f: (x: unknown) => x is boolean | null | undefined;
     o: (x: unknown) => x is boolean | null | undefined;

package/core/validators/validators.js

@@ -444,6 +444,7 @@ exports.isStringOrNegativeOne = either(checks_1.isString, (v) => v === -1);
 exports.isRestrictions = strictObjectValidator({
     'b': nullableOption(checks_1.isBoolean),
     'p': nullableOption(checks_1.isBoolean),
+    's': nullableOption(checks_1.isBoolean),
     'c': nullableOption(checks_1.isBoolean),
     'f': nullableOption(checks_1.isBoolean),
     'o': nullableOption(checks_1.isBoolean),

package/data/collectiondefinition.d.ts

@@ -1,10 +1,12 @@
 import { type SerializedFields } from '../core/data/serializedfield/serializedfields';
 import { isSerializedSchema, type SerializedSchema } from '../core/data/serializedfield/serializedschema';
 import { type SchemaDefinition } from './schemadefinition';
+/** A complete description of a collection: its schema and the ordered set of items that conform to it. */
 export interface CollectionDefinition {
     schema: SchemaDefinition;
     items: Map<string, SerializedFields>;
 }
+/** @ignore */
 export declare const isSerializedCollectionDefinition: (subject: unknown) => subject is import("..").DestructureGuardedTypeObj<{
     Schema: typeof isSerializedSchema;
     Items: (val: unknown) => val is [string, Record<string | number, import("../core/data/serializedfield/serializedfields").SerializedFieldType>][];

package/data/collectiondefinition.js

@@ -8,6 +8,7 @@ const serializedfields_1 = require("../core/data/serializedfield/serializedfield
 const serializedschema_1 = require("../core/data/serializedfield/serializedschema");
 const validators_1 = require("../core/validators/validators");
 const schemadefinition_1 = require("./schemadefinition");
+/** @ignore */
 exports.isSerializedCollectionDefinition = (0, validators_1.objectValidator)({
     'Schema': serializedschema_1.isSerializedSchema,
     'Items': (0, checks_1.isTypedArray)((0, checks_1.isPair)(checks_1.isString, serializedfields_1.isSerializedFields)),

package/data/collectionerrortypes.d.ts

@@ -1 +1,5 @@
+/**
+ * Reserved key for entries in a collection's error map that report the status of the upstream schema sync.
+ * Use the `schemaOutOfSyncStatus` and `schemaOKStatus` helpers to construct the corresponding values.
+ */
 export declare const CollectionUpstreamSchemaStatus = "__CollectionUpstreamSchemaStatus__";

package/data/collectionerrortypes.js

@@ -1,4 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CollectionUpstreamSchemaStatus = void 0;
+/**
+ * Reserved key for entries in a collection's error map that report the status of the upstream schema sync.
+ * Use the `schemaOutOfSyncStatus` and `schemaOKStatus` helpers to construct the corresponding values.
+ */
 exports.CollectionUpstreamSchemaStatus = '__CollectionUpstreamSchemaStatus__';

package/data/dataupdatefiltertype.d.ts

@@ -7,4 +7,5 @@ export declare const DataUpdateFilterType: {
     /** All updates to items already present on the document will be sent to the document. New items created in the data source will not be created on the document. */
     readonly CurrentItemUpdates: "CurrentItemUpdates";
 };
+/** One of the values in {@link DataUpdateFilterType}. */
 export type DataUpdateFilterType = (typeof DataUpdateFilterType)[keyof typeof DataUpdateFilterType];

package/data/displayoptiondefinition.d.ts

@@ -1,14 +1,19 @@
 import { DisplayOptionType, type SerializedDisplayOption } from '../core/data/serializedfield/serializeddisplayoption';
+/** Display option that renders a field as a multi-user select picker, allowing multiple users to be assigned. */
 export interface DisplayMultiUserEditDisplayOptionDefinition {
     type: typeof DisplayOptionType.DisplayMultiUserSelect;
     value?: undefined;
 }
+/** Display option that shows helper text beneath a field to guide users on expected input. */
 export interface HelperTextDisplayOptionDefinition {
     type: typeof DisplayOptionType.HelperText;
     value?: string | undefined;
 }
+/** Union of all supported display option types that control how a field is rendered in the UI. */
 export type DisplayOptionDefinition = DisplayMultiUserEditDisplayOptionDefinition | HelperTextDisplayOptionDefinition;
+/** Construct a {@link DisplayOptionDefinition} for the given type, validating that the value (if any) matches what the type expects. */
 export declare function createDisplayOptionDefinition(type: DisplayOptionType, value?: number | string): DisplayOptionDefinition;
+/** @ignore */
 export declare const isDisplayOptionDefinition: (x: unknown) => x is DisplayOptionDefinition;
 /** @ignore */
 export declare function serializeDisplayOptionDefinition(option: DisplayOptionDefinition): SerializedDisplayOption;

package/data/displayoptiondefinition.js

@@ -7,6 +7,7 @@ const assertnever_1 = require("../core/assertnever");
 const checks_1 = require("../core/checks");
 const serializeddisplayoption_1 = require("../core/data/serializedfield/serializeddisplayoption");
 const validators_1 = require("../core/validators/validators");
+/** Construct a {@link DisplayOptionDefinition} for the given type, validating that the value (if any) matches what the type expects. */
 function createDisplayOptionDefinition(type, value) {
     switch (type) {
         case serializeddisplayoption_1.DisplayOptionType.DisplayMultiUserSelect:
@@ -36,6 +37,7 @@ const isHelperTextDisplayOptionDefinition = (0, validators_1.objectValidator)({
 const isDisplayMultiUserSelectDisplayOptionDefinition = (0, validators_1.objectValidator)({
     type: isDisplayMultiUserSelectType,
 });
+/** @ignore */
 exports.isDisplayOptionDefinition = (0, validators_1.either)(isHelperTextDisplayOptionDefinition, isDisplayMultiUserSelectDisplayOptionDefinition);
 /** @ignore */
 function serializeDisplayOptionDefinition(option) {

package/data/fieldconstraintdefinition.d.ts

@@ -1,45 +1,54 @@
 import { isNumber, isUndefined } from '../core/checks';
 import { FieldConstraintType, type SerializedFieldConstraint } from '../core/data/serializedfield/serializedfielddefinition';
+/** Constraint that marks a field as required, preventing empty values. */
 export interface RequiredFieldConstraintDefinition {
     type: typeof FieldConstraintType.REQUIRED;
     value?: undefined;
     reason?: string | undefined;
 }
+/** Constraint that locks a field, preventing users from editing its value. */
 export interface LockedFieldConstraintDefinition {
     type: typeof FieldConstraintType.LOCKED;
     value?: undefined;
     reason?: string | undefined;
 }
+/** Constraint that enforces a minimum numeric value for a field. */
 export interface MinValueFieldConstraintDefinition {
     type: typeof FieldConstraintType.MIN_VALUE;
     value: number;
     reason?: string | undefined;
 }
+/** Constraint that enforces a maximum numeric value for a field. */
 export interface MaxValueFieldConstraintDefinition {
     type: typeof FieldConstraintType.MAX_VALUE;
     value: number;
     reason?: string | undefined;
 }
+/** Constraint that restricts a text field to a single line, disallowing newline characters. */
 export interface SingleLineFieldConstraintDefinition {
     type: typeof FieldConstraintType.SINGLE_LINE_ONLY;
     value?: undefined;
     reason?: string | undefined;
 }
+/** Constraint that disallows whitespace characters in a field value. */
 export interface NoWhitespaceFieldConstraintDefinition {
     type: typeof FieldConstraintType.NO_WHITESPACE;
     value?: undefined;
     reason?: string | undefined;
 }
+/** Constraint that requires a field value to be unique across all items in the collection when edited. */
 export interface UniqueEditFieldConstraintDefinition {
     type: typeof FieldConstraintType.UNIQUE_EDIT;
     value?: undefined;
     reason?: string | undefined;
 }
+/** Constraint that enforces a maximum character length for a text field. */
 export interface MaxLengthConstraintDefinition {
     type: typeof FieldConstraintType.MAX_LENGTH;
     value: number;
     reason?: string | undefined;
 }
+/** Constraint that limits the number of decimal places allowed in a numeric field value. */
 export interface MaxDecimalPlacesConstraintDefinition {
     type: typeof FieldConstraintType.MAX_DECIMAL_PLACES;
     value: number;
@@ -51,9 +60,13 @@ export interface MaxDecimalLengthConstraintDefinition {
     value: number;
     reason?: string | undefined;
 }
+/** Union of all supported field constraint types that can be applied to a collection schema field. */
 export type FieldConstraintDefinition = RequiredFieldConstraintDefinition | LockedFieldConstraintDefinition | MinValueFieldConstraintDefinition | MaxValueFieldConstraintDefinition | SingleLineFieldConstraintDefinition | NoWhitespaceFieldConstraintDefinition | UniqueEditFieldConstraintDefinition | MaxLengthConstraintDefinition | MaxDecimalPlacesConstraintDefinition | MaxDecimalLengthConstraintDefinition;
+/** Construct a {@link FieldConstraintDefinition} for the given type, validating that the value (if any) matches what the type expects. */
 export declare function createFieldConstraintDefinition(type: FieldConstraintType, value?: number, reason?: string): FieldConstraintDefinition;
+/** @ignore */
 export declare function numericFieldConstraintValidator(val: unknown): val is typeof FieldConstraintType.MIN_VALUE | typeof FieldConstraintType.MAX_VALUE | typeof FieldConstraintType.MAX_LENGTH | typeof FieldConstraintType.MAX_DECIMAL_PLACES | typeof FieldConstraintType.MAX_DECIMAL_LENGTH;
+/** @ignore */
 export declare const isFieldConstraintDefinition: (x: unknown) => x is import("..").DestructureGuardedTypeObj<{
     type: (x: unknown) => x is {} extends {
         readonly REQUIRED: "required";

package/data/fieldconstraintdefinition.js

@@ -8,6 +8,7 @@ const assertnever_1 = require("../core/assertnever");
 const checks_1 = require("../core/checks");
 const serializedfielddefinition_1 = require("../core/data/serializedfield/serializedfielddefinition");
 const validators_1 = require("../core/validators/validators");
+/** Construct a {@link FieldConstraintDefinition} for the given type, validating that the value (if any) matches what the type expects. */
 function createFieldConstraintDefinition(type, value, reason) {
     switch (type) {
         case serializedfielddefinition_1.FieldConstraintType.REQUIRED:
@@ -33,6 +34,7 @@ function createFieldConstraintDefinition(type, value, reason) {
             (0, assertnever_1.assertNever)(type);
     }
 }
+/** @ignore */
 function numericFieldConstraintValidator(val) {
     return (val === serializedfielddefinition_1.FieldConstraintType.MIN_VALUE ||
         val === serializedfielddefinition_1.FieldConstraintType.MAX_VALUE ||
@@ -40,6 +42,7 @@ function numericFieldConstraintValidator(val) {
         val === serializedfielddefinition_1.FieldConstraintType.MAX_DECIMAL_PLACES ||
         val === serializedfielddefinition_1.FieldConstraintType.MAX_DECIMAL_LENGTH);
 }
+/** @ignore */
 exports.isFieldConstraintDefinition = (0, validators_1.both)((0, validators_1.objectValidator)({
     'type': serializedfielddefinition_1.isFieldConstraintType,
 }), (0, validators_1.either)((0, validators_1.objectValidator)({ 'type': numericFieldConstraintValidator, 'value': checks_1.isNumber }), (0, validators_1.objectValidator)({

package/data/patchcollectionproxy.d.ts

@@ -1,6 +1,7 @@
 import { EditorClient } from '../editorclient';
 import { CollectionProxy } from './collectionproxy';
 import { DataItemProxy } from './dataitemproxy';
+/** A data item that has been modified locally but not yet synced back to the external data source, exposing both the current and original values. */
 export declare class PatchedDataItemProxy extends DataItemProxy {
     /**
      * The names of all fields that have been changed locally on this data item and
@@ -24,6 +25,7 @@ export declare class PatchedDataItemProxy extends DataItemProxy {
      */
     original: DataItemProxy, client: EditorClient);
 }
+/** Provides access to locally added, deleted, and changed data items within a collection that have not yet been synced to the external data source. Obtained via CollectionProxy.getLocalChanges(). */
 export declare class PatchCollectionProxy {
     private readonly client;
     private readonly branchedCollection;

package/data/patchcollectionproxy.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PatchCollectionProxy = exports.PatchedDataItemProxy = void 0;
 const dataitemproxy_1 = require("./dataitemproxy");
+/** A data item that has been modified locally but not yet synced back to the external data source, exposing both the current and original values. */
 class PatchedDataItemProxy extends dataitemproxy_1.DataItemProxy {
     constructor(primaryKey, collection, 
     /**
@@ -20,6 +21,7 @@ class PatchedDataItemProxy extends dataitemproxy_1.DataItemProxy {
     }
 }
 exports.PatchedDataItemProxy = PatchedDataItemProxy;
+/** Provides access to locally added, deleted, and changed data items within a collection that have not yet been synced to the external data source. Obtained via CollectionProxy.getLocalChanges(). */
 class PatchCollectionProxy {
     /**
      * Use CollectionProxy.getLocalChanges() to get a PatchCollectionProxy rather

package/data/patcherrortype.d.ts

@@ -5,4 +5,5 @@ export declare const PatchErrorType: {
     readonly Default: "default";
     readonly Permissions: "permissions";
 };
+/** One of the values in {@link PatchErrorType}. */
 export type PatchErrorType = (typeof PatchErrorType)[keyof typeof PatchErrorType];

package/data/referencekeydefinition.d.ts

@@ -2,16 +2,16 @@ import { type SerializedReferenceKeyType } from '../core/data/referencekeys/seri
 import type { SerializedFieldType } from '../core/data/serializedfield/serializedfields';
 import { type 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
+ * A reference key that points to a {@link DataItemProxy | DataItem} in a
+ * {@link CollectionProxy | Collection}. This is the most common type of
  * reference key to create.
  *
- * For more information, see the [Developer Guide](/extension-api#guide-reference-keys).
+ * For more information, see the [Developer Guide](doc:editor-extension-data#how-to-associate-a-record-with-a-shape-on-canvas).
  */
 export interface CollectionReferenceKeyDefinition {
     /** The ID of the collection referenced */
     collectionId: string;
-    /** The [primary key](#classes_data_dataitemproxy-DataItemProxy_primarykey) of the data item referenced */
+    /** The {@link DataItemProxy.primaryKey | primary key} of the data item referenced */
     primaryKey: string;
     /** If true, prevent the user from editing the field values of this reference key through the normal UI */
     readonly?: boolean | undefined;
@@ -25,7 +25,7 @@ export interface CollectionReferenceKeyDefinition {
 /**
  * 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)
+ * for whatever reason want to construct an actual {@link CollectionProxy | Collection}
  * to house that data.
  */
 export interface FlattenedReferenceDefinition {
@@ -36,6 +36,7 @@ export interface FlattenedReferenceDefinition {
     /** Field values available at this reference key */
     data: Record<string, SerializedFieldType>;
 }
+/** A reference key definition that links a canvas element to either a data item in a collection or a flattened set of inline field values. */
 export type ReferenceKeyDefinition = CollectionReferenceKeyDefinition | FlattenedReferenceDefinition;
 /** @ignore */
 export declare function isCollectionReferenceKeyDefinition(def: ReferenceKeyDefinition): def is CollectionReferenceKeyDefinition;

package/data/referencekeyproxy.d.ts

@@ -1,6 +1,7 @@
 import { type SerializedReferenceKeyType } from '../core/data/referencekeys/serializedreferencekey';
 import { EditorClient } from '../editorclient';
 import { ReferenceKeyDefinition } from './referencekeydefinition';
+/** Proxy for a reference key that links a block on the canvas to a data item in a collection, enabling data-linked shapes. */
 export declare class ReferenceKeyProxy {
     readonly elementId: string | undefined;
     readonly key: string | number;

package/data/referencekeyproxy.js

@@ -4,6 +4,7 @@ exports.ReferenceKeyProxy = void 0;
 const serializedreferencekey_1 = require("../core/data/referencekeys/serializedreferencekey");
 const collectionproxy_1 = require("./collectionproxy");
 const referencekeydefinition_1 = require("./referencekeydefinition");
+/** Proxy for a reference key that links a block on the canvas to a data item in a collection, enabling data-linked shapes. */
 class ReferenceKeyProxy {
     constructor(elementId, key, client, settings) {
         this.elementId = elementId;