lucid-extension-sdk 1.1.2 → 1.2.0

package/core/sharedcardintegration/sharedregistryutil.js

@@ -1,8 +1,215 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+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");
+/**
+ * Serializes a `SearchResult` into the wire-format object the editor expects. Shared between the
+ * import-modal `search` path and the auto-sync `searchQueryString` / `searchFields` paths.
+ */
+function serializeSearchResult(searchResult) {
+    var _a;
+    return {
+        'srs': searchResult.searchResults.map((resultPerCollection) => ({
+            'd': (0, collectiondefinition_1.serializeCollectionDefinition)(resultPerCollection.data),
+            'f': (0, cardintegrationdefinitions_1.serializeCardFieldArrayDefinition)(resultPerCollection.fields),
+            'm': resultPerCollection.partialImportMetadata && {
+                'cid': resultPerCollection.partialImportMetadata.collectionId,
+                'sid': resultPerCollection.partialImportMetadata.syncDataSourceId,
+            },
+        })),
+        'ipsr': searchResult.itemsPerSearchResult,
+        'e': searchResult.error,
+        'bs': (_a = searchResult.banners) === null || _a === void 0 ? void 0 : _a.map((banner) => ({
+            'ty': banner.type,
+            'msg': banner.message,
+            'btyp': banner.bannerType,
+            'actbtn': banner.actionButton
+                ? {
+                    'lab': banner.actionButton.label,
+                    'aid': banner.actionButton.actionId,
+                    'href': banner.actionButton.href,
+                }
+                : undefined,
+        })),
+    };
+}
+/**
+ * Serializes import results (single or array) to the wire-format the editor expects. Shared
+ * between the import-modal `import` path, the dependency-mapping path, and the auto-sync `sync*`
+ * paths.
+ */
+function serializeImportResults(result) {
+    if ((0, checks_1.isArray)(result)) {
+        return result.map((importResult) => ({
+            'c': importResult.collection.id,
+            'pks': importResult.primaryKeys,
+        }));
+    }
+    return {
+        'c': result.collection.id,
+        'pks': result.primaryKeys,
+    };
+}
+/**
+ * Registers the editor-side actions for a `CardIntegrationAutoSyncConfig` on the given client and
+ * returns the corresponding `AutoSyncSettings` wire-format payload. Used by both
+ * `LucidCardIntegrationRegistry` and `LucidSpreadsheetIntegrationRegistry`.
+ */
+function registerAutoSync(client, autoSync, getNextHookName) {
+    var _a, _b;
+    const serialized = {
+        'gsf': getNextHookName(),
+    };
+    if (autoSync.phrases) {
+        serialized['p'] = {
+            'h': autoSync.phrases.header,
+            'l': autoSync.phrases.label,
+            'qph': autoSync.phrases.queryPlaceholder,
+            'rnml': getNextHookName(),
+            'nml': autoSync.phrases.noMatchedLabel,
+            'esl': autoSync.phrases.emptyStateLabel,
+        };
+        client.registerAction(serialized['p']['rnml'], ({ 'g': inputSoFar }) => {
+            var _a;
+            if (!(0, cardintegrationautosyncconfig_1.isSupportedAutoSyncGeneratorType)(inputSoFar)) {
+                return '';
+            }
+            return (_a = autoSync.phrases) === null || _a === void 0 ? void 0 : _a.removeNonMatchingLabel(inputSoFar);
+        });
+        if ((_a = autoSync.phrases) === null || _a === void 0 ? void 0 : _a.syncingGrowlMessage) {
+            serialized['p']['sgm'] = getNextHookName();
+            client.registerAction(serialized['p']['sgm'], ({ 'c': count }) => {
+                var _a, _b;
+                return (_b = (_a = autoSync.phrases) === null || _a === void 0 ? void 0 : _a.syncingGrowlMessage) === null || _b === void 0 ? void 0 : _b.call(_a, count);
+            });
+        }
+        if ((_b = autoSync.phrases) === null || _b === void 0 ? void 0 : _b.removingGrowlMessage) {
+            serialized['p']['rgm'] = getNextHookName();
+            client.registerAction(serialized['p']['rgm'], ({ 'c': count }) => {
+                var _a, _b;
+                return (_b = (_a = autoSync.phrases) === null || _a === void 0 ? void 0 : _a.removingGrowlMessage) === null || _b === void 0 ? void 0 : _b.call(_a, count);
+            });
+        }
+    }
+    client.registerAction(serialized['gsf'], async ({ 'i': inputSoFar }) => {
+        const result = await autoSync.getSyncDataSourceIdField(new Map(inputSoFar));
+        return (0, cardintegrationdefinitions_1.serializeCardFieldArrayDefinition)(result);
+    });
+    if ('searchFields' in autoSync) {
+        const fieldOnlyAutoSync = autoSync;
+        serialized['gdff'] = getNextHookName();
+        client.registerAction(serialized['gdff'], async ({ 's': searchSoFar }) => {
+            const result = await fieldOnlyAutoSync.getDefaultFilterFields(new Map(searchSoFar));
+            return (0, cardintegrationdefinitions_1.serializeCardFieldArrayDefinition)(result);
+        });
+        if (fieldOnlyAutoSync.getMoreFilterFields) {
+            serialized['gmff'] = getNextHookName();
+            client.registerAction(serialized['gmff'], async ({ 's': searchSoFar }) => {
+                var _a;
+                const result = await ((_a = fieldOnlyAutoSync.getMoreFilterFields) === null || _a === void 0 ? void 0 : _a.call(fieldOnlyAutoSync, new Map(searchSoFar)));
+                return (0, cardintegrationdefinitions_1.serializeCardFieldArrayDefinition)(result !== null && result !== void 0 ? result : []);
+            });
+        }
+        serialized['sf'] = getNextHookName();
+        client.registerAction(serialized['sf'], async ({ 'f': fields, 'if': instanceFields, 'pn': pageNumber, 'npt': nextPageToken }) => {
+            const result = await fieldOnlyAutoSync.searchFields(new Map(fields), new Map(instanceFields), pageNumber, nextPageToken);
+            if (result) {
+                return serializeSearchResult(result);
+            }
+            return serializeSearchResult({ searchResults: [], error: 'Unknown Error Occurred' });
+        });
+        serialized['syf'] = getNextHookName();
+        client.registerAction(serialized['syf'], async ({ 'f': fields, 'if': instanceFields }) => {
+            var _a;
+            const result = (_a = (await fieldOnlyAutoSync.syncFields(new Map(fields), new Map(instanceFields)))) !== null && _a !== void 0 ? _a : [];
+            return serializeImportResults(result);
+        });
+    }
+    else {
+        const queryStringAutoSync = autoSync;
+        if (queryStringAutoSync.searchQueryString) {
+            serialized['sqs'] = getNextHookName();
+            client.registerAction(serialized['sqs'], async ({ 'qs': queryString, 'of': otherFields, 'pn': pageNumber, 'npt': nextPageToken, }) => {
+                var _a;
+                const result = await ((_a = queryStringAutoSync.searchQueryString) === null || _a === void 0 ? void 0 : _a.call(queryStringAutoSync, queryString, new Map(otherFields), pageNumber, nextPageToken));
+                if (result) {
+                    return serializeSearchResult(result);
+                }
+                return serializeSearchResult({ searchResults: [], error: 'Unknown Error Occurred' });
+            });
+        }
+        if (queryStringAutoSync.syncQueryString) {
+            serialized['syqs'] = getNextHookName();
+            client.registerAction(serialized['syqs'], async ({ 'qs': queryString, 'of': otherFields }) => {
+                var _a, _b;
+                const result = (_b = (await ((_a = queryStringAutoSync.syncQueryString) === null || _a === void 0 ? void 0 : _a.call(queryStringAutoSync, queryString, new Map(otherFields))))) !== null && _b !== void 0 ? _b : [];
+                return serializeImportResults(result);
+            });
+        }
+        if (queryStringAutoSync.convertFiltersToQueryString) {
+            serialized['cftqs'] = getNextHookName();
+            client.registerAction(serialized['cftqs'], async ({ 'ff': filterFields }) => {
+                var _a;
+                const result = await ((_a = queryStringAutoSync.convertFiltersToQueryString) === null || _a === void 0 ? void 0 : _a.call(queryStringAutoSync, new Map(filterFields)));
+                if ((0, cardintegrationautosyncconfig_1.isConvertFiltersToQueryStringResult)(result)) {
+                    return {
+                        'qs': result.queryString,
+                        'e': result.error,
+                    };
+                }
+                return result;
+            });
+        }
+        if (queryStringAutoSync.getDefaultFilterFields) {
+            serialized['gdff'] = getNextHookName();
+            client.registerAction(serialized['gdff'], async ({ 's': searchSoFar }) => {
+                var _a, _b;
+                const result = (_b = (await ((_a = queryStringAutoSync.getDefaultFilterFields) === null || _a === void 0 ? void 0 : _a.call(queryStringAutoSync, new Map(searchSoFar))))) !== null && _b !== void 0 ? _b : [];
+                return (0, cardintegrationdefinitions_1.serializeCardFieldArrayDefinition)(result);
+            });
+        }
+        if (queryStringAutoSync.getMoreFilterFields) {
+            serialized['gmff'] = getNextHookName();
+            client.registerAction(serialized['gmff'], async ({ 's': searchSoFar }) => {
+                var _a;
+                const result = await ((_a = queryStringAutoSync.getMoreFilterFields) === null || _a === void 0 ? void 0 : _a.call(queryStringAutoSync, new Map(searchSoFar)));
+                return (0, cardintegrationdefinitions_1.serializeCardFieldArrayDefinition)(result !== null && result !== void 0 ? result : []);
+            });
+        }
+    }
+    if (autoSync.documentPresetSetupFields) {
+        const documentPresetSetupFields = autoSync.documentPresetSetupFields;
+        serialized['dpf'] = {
+            'gsf': getNextHookName(),
+            'gpv': getNextHookName(),
+        };
+        client.registerAction(serialized['dpf']['gsf'], async ({ 's': searchSoFar }) => {
+            const result = await documentPresetSetupFields.getSearchFields(new Map(searchSoFar));
+            return (0, cardintegrationdefinitions_1.serializeCardFieldArrayDefinition)(result);
+        });
+        client.registerAction(serialized['dpf']['gpv'], async ({ 'f': fields }) => {
+            const result = await documentPresetSetupFields.generatePresetValue(new Map(fields));
+            return {
+                'dcn': result.dataConnectorName,
+                'iid': result.instanceId,
+                'q': result.query,
+            };
+        });
+    }
+    return serialized;
+}
 function registerDependencyMapping(client, dependencyMapping, serialized, getNextHookName) {
     serialized['sdm'] = dependencyMapping.showDependencyMapping;
     const dependencyMappingPhrases = dependencyMapping.dependencyMappingPhrases;
@@ -94,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,4 +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';
@@ -119,4 +122,14 @@ 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.
+     */
+    autoSync?: CardIntegrationAutoSyncConfig | undefined;
 }

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,
@@ -145,6 +148,9 @@ class LucidSpreadsheetIntegrationRegistry {
             });
         }
         this.registerDependencyMapping(client, spreadsheetIntegration, serialized);
+        if (spreadsheetIntegration.autoSync) {
+            serialized['as'] = (0, sharedregistryutil_1.registerAutoSync)(client, spreadsheetIntegration.autoSync, () => LucidSpreadsheetIntegrationRegistry.nextHookName());
+        }
         if (spreadsheetIntegration.getUpstreamSourceUrl) {
             const getUpstreamSourceUrl = LucidSpreadsheetIntegrationRegistry.nextHookName();
             client.registerAction(getUpstreamSourceUrl, async (message) => {

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;