lucid-extension-sdk 0.0.433 → 0.0.435

package/core/data/fieldspecification.d.ts

@@ -1,4 +1,5 @@
-import { FieldConstraintDefinition } from '../../data/schemadefinition';
+import { DisplayOptionDefinition } from '../../data/displayoptiondefinition';
+import { FieldConstraintDefinition } from '../../data/fieldconstraintdefinition';
 import { CollectionEnumFieldType } from './fieldtypedefinition/collectionenumfieldtype';
 import { DeserializedMapEnumFieldType } from './fieldtypedefinition/deserializedmapenumfieldtype';
 import { FieldTypeArray } from './fieldtypedefinition/fieldtypearray';
@@ -25,11 +26,12 @@ type TsTypeOf<X> = X extends ScalarFieldTypeEnum.ANY ? unknown : X extends Scala
  * additional (and valuable) user functionality. This includes better support in the edit panel, and better user facing
  * descriptions of your fields.
  */
-export declare function declareSchema<Names extends string, Types extends Readonly<FieldTypeDefinition>, Constraint extends FieldConstraintDefinition, Fields extends {
+export declare function declareSchema<Names extends string, Types extends Readonly<FieldTypeDefinition>, Constraint extends FieldConstraintDefinition, DisplayOption extends DisplayOptionDefinition, Fields extends {
     [Name in Names]: {
         type: Types;
         constraints?: readonly Constraint[];
         mapping?: readonly SemanticKind[] | readonly SemanticFields[] | readonly LucidFields[] | undefined;
+        displayOptions?: readonly DisplayOption[] | undefined;
     };
 }, PrimaryKey extends keyof Fields>({ primaryKey, fields }: {
     primaryKey: PrimaryKey[];
@@ -41,6 +43,7 @@ export declare function declareSchema<Names extends string, Types extends Readon
         type: FieldTypeDefinition;
         constraints: FieldConstraintDefinition[];
         mapping: readonly SemanticKind[] | readonly SemanticFields[] | readonly LucidFields[];
+        displayOptions: readonly DisplayOption[];
     }[];
     primaryKey: FormattedPrimaryKey<Fields, PrimaryKey>;
     fromItemsSparse: (items: PartialItemType<typeof fields, PrimaryKey>[]) => Map<string, PartialItemType<Fields, PrimaryKey>>;

package/core/data/fieldspecification.js

@@ -22,12 +22,13 @@ function declareSchema({ primaryKey, fields }) {
     const primaryKeyObj = new FormattedPrimaryKey(...primaryKey);
     return {
         example: fields,
-        array: Object.entries(fields).map(([name, { type, constraints, mapping }]) => {
+        array: Object.entries(fields).map(([name, { type, constraints, mapping, displayOptions: displayOptions }]) => {
             return {
                 'name': name,
                 'type': isArrayAndAssertReadonly(type) ? type.slice() : type,
                 'constraints': constraints,
                 'mapping': mapping,
+                'displayOptions': displayOptions,
             };
         }),
         primaryKey: primaryKeyObj,

package/core/data/serializedfield/serializeddisplayoption.d.ts

@@ -0,0 +1,17 @@
+import { UnsafeJsonSerializableOrUndefined } from '../../jsonserializable';
+/**
+ * @experimental
+ * The options here must match com.lucidchart.data.model.fielddefinition.DisplayOptionType on the backend
+ */
+export declare enum DisplayOptionType {
+    DisplayMultiUserSelect = "displayMultiUserSelect"
+}
+export declare const isDisplayOptionType: (x: unknown) => x is DisplayOptionType.DisplayMultiUserSelect;
+export type SerializedDisplayOption = {
+    'Type': DisplayOptionType;
+    'Details'?: UnsafeJsonSerializableOrUndefined;
+};
+export declare const isSerializedDisplayOption: (subject: unknown) => subject is import("../../guards").DestructureGuardedTypeObj<{
+    Type: (x: unknown) => x is DisplayOptionType.DisplayMultiUserSelect;
+    Details: (x: unknown) => x is UnsafeJsonSerializableOrUndefined;
+}>;

package/core/data/serializedfield/serializeddisplayoption.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSerializedDisplayOption = exports.isDisplayOptionType = exports.DisplayOptionType = void 0;
+const jsonserializable_1 = require("../../jsonserializable");
+const validators_1 = require("../../validators/validators");
+/**
+ * @experimental
+ * The options here must match com.lucidchart.data.model.fielddefinition.DisplayOptionType on the backend
+ */
+var DisplayOptionType;
+(function (DisplayOptionType) {
+    DisplayOptionType["DisplayMultiUserSelect"] = "displayMultiUserSelect";
+})(DisplayOptionType || (exports.DisplayOptionType = DisplayOptionType = {}));
+exports.isDisplayOptionType = (0, validators_1.enumValidator)(DisplayOptionType);
+exports.isSerializedDisplayOption = (0, validators_1.objectValidator)({
+    'Type': (0, validators_1.enumValidator)(DisplayOptionType),
+    'Details': (0, validators_1.option)(jsonserializable_1.isJsonSerializableOrUndefined),
+});

package/core/data/serializedfield/serializedfielddefinition.d.ts

@@ -4,6 +4,7 @@ import { SerializedFieldTypeDefinition, isSerializedFieldTypeDefinition } from '
 import { LucidFields } from '../fieldtypedefinition/lucidfields';
 import { SemanticFields } from '../fieldtypedefinition/semanticfields';
 import { SemanticKind } from '../fieldtypedefinition/semantickind';
+import { SerializedDisplayOption } from './serializeddisplayoption';
 export declare enum FieldConstraintType {
     REQUIRED = "required",
     LOCKED = "locked",
@@ -31,6 +32,7 @@ export type SerializedFieldDefinition = {
     'Constraints'?: SerializedFieldConstraint[] | undefined;
     'SyncSchema'?: string | undefined;
     'Mapping'?: readonly LucidFields[] | readonly SemanticFields[] | readonly SemanticKind[] | undefined;
+    'DisplayOptions'?: SerializedDisplayOption[] | undefined;
 };
 export declare const isSerializedFieldDefinition: (subject: unknown) => subject is import("../../guards").DestructureGuardedTypeObj<{
     Name: typeof isString;
@@ -42,4 +44,8 @@ export declare const isSerializedFieldDefinition: (subject: unknown) => subject
     }>[] | undefined;
     SyncSchema: (x: unknown) => x is string | undefined;
     Mapping: (x: unknown) => x is LucidFields[] | SemanticKind[] | undefined;
+    DisplayOptions: (x: unknown) => x is import("../../guards").DestructureGuardedTypeObj<{
+        Type: (x: unknown) => x is import("./serializeddisplayoption").DisplayOptionType.DisplayMultiUserSelect;
+        Details: (x: unknown) => x is UnsafeJsonSerializableOrUndefined;
+    }>[] | undefined;
 }>;

package/core/data/serializedfield/serializedfielddefinition.js

@@ -6,6 +6,7 @@ const validators_1 = require("../../validators/validators");
 const fieldtypedefinition_1 = require("../fieldtypedefinition/fieldtypedefinition");
 const lucidfields_1 = require("../fieldtypedefinition/lucidfields");
 const semantickind_1 = require("../fieldtypedefinition/semantickind");
+const serializeddisplayoption_1 = require("./serializeddisplayoption");
 // The options here must match com.lucidchart.data.model.fielddefinition.FieldConstraintType on the backend
 var FieldConstraintType;
 (function (FieldConstraintType) {
@@ -30,4 +31,5 @@ exports.isSerializedFieldDefinition = (0, validators_1.strictObjectValidator)({
     'Constraints': (0, validators_1.option)((0, validators_1.arrayValidator)(exports.isSerializedFieldConstraint)),
     'SyncSchema': (0, validators_1.option)(checks_1.isString),
     'Mapping': (0, validators_1.option)((0, validators_1.either)((0, validators_1.arrayValidator)(lucidfields_1.isLucidFields), (0, validators_1.arrayValidator)(semantickind_1.isSemanticKind))),
+    'DisplayOptions': (0, validators_1.option)((0, validators_1.arrayValidator)(serializeddisplayoption_1.isSerializedDisplayOption)),
 });

package/data/displayoptiondefinition.d.ts

@@ -0,0 +1,14 @@
+import { isUndefined } from '../core/checks';
+import { DisplayOptionType, SerializedDisplayOption } from '../core/data/serializedfield/serializeddisplayoption';
+export interface DisplayMultiUserEditDisplayOptionDefinition {
+    type: DisplayOptionType.DisplayMultiUserSelect;
+    value?: undefined;
+}
+export type DisplayOptionDefinition = DisplayMultiUserEditDisplayOptionDefinition;
+export declare function createDisplayOptionDefinition(type: DisplayOptionType, value?: number): DisplayOptionDefinition;
+export declare const isDisplayOptionDefinition: (subject: unknown) => subject is import("..").DestructureGuardedTypeObj<{
+    type: (x: unknown) => x is DisplayOptionType.DisplayMultiUserSelect;
+    value: typeof isUndefined;
+}>;
+/** @ignore */
+export declare function serializeDisplayOptionDefinition(option: DisplayOptionDefinition): SerializedDisplayOption;

package/data/displayoptiondefinition.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeDisplayOptionDefinition = exports.isDisplayOptionDefinition = exports.createDisplayOptionDefinition = void 0;
+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");
+function createDisplayOptionDefinition(type, value) {
+    switch (type) {
+        case serializeddisplayoption_1.DisplayOptionType.DisplayMultiUserSelect:
+            if (value !== undefined) {
+                throw new Error('Invalid display option value');
+            }
+            return { type };
+        default:
+            (0, assertnever_1.assertNever)(type);
+    }
+}
+exports.createDisplayOptionDefinition = createDisplayOptionDefinition;
+exports.isDisplayOptionDefinition = (0, validators_1.objectValidator)({
+    'type': serializeddisplayoption_1.isDisplayOptionType,
+    'value': checks_1.isUndefined, // value is always undefined for now, update as more complex options are added
+});
+/** @ignore */
+function serializeDisplayOptionDefinition(option) {
+    return {
+        'Type': option.type,
+        'Details': option.value,
+    };
+}
+exports.serializeDisplayOptionDefinition = serializeDisplayOptionDefinition;

package/data/fieldconstraintdefinition.d.ts

@@ -0,0 +1,58 @@
+import { isNumber, isUndefined } from '../core/checks';
+import { FieldConstraintType, SerializedFieldConstraint } from '../core/data/serializedfield/serializedfielddefinition';
+export interface RequiredFieldConstraintDefinition {
+    type: FieldConstraintType.REQUIRED;
+    value?: undefined;
+    reason?: string | undefined;
+}
+export interface LockedFieldConstraintDefinition {
+    type: FieldConstraintType.LOCKED;
+    value?: undefined;
+    reason?: string | undefined;
+}
+export interface MinValueFieldConstraintDefinition {
+    type: FieldConstraintType.MIN_VALUE;
+    value: number;
+    reason?: string | undefined;
+}
+export interface MaxValueFieldConstraintDefinition {
+    type: FieldConstraintType.MAX_VALUE;
+    value: number;
+    reason?: string | undefined;
+}
+export interface SingleLineFieldConstraintDefinition {
+    type: FieldConstraintType.SINGLE_LINE_ONLY;
+    value?: undefined;
+    reason?: string | undefined;
+}
+export interface NoWhitespaceFieldConstraintDefinition {
+    type: FieldConstraintType.NO_WHITESPACE;
+    value?: undefined;
+    reason?: string | undefined;
+}
+export interface UniqueEditFieldConstraintDefinition {
+    type: FieldConstraintType.UNIQUE_EDIT;
+    value?: undefined;
+    reason?: string | undefined;
+}
+export interface MaxLengthConstraintDefinition {
+    type: FieldConstraintType.MAX_LENGTH;
+    value: number;
+    reason?: string | undefined;
+}
+export type FieldConstraintDefinition = RequiredFieldConstraintDefinition | LockedFieldConstraintDefinition | MinValueFieldConstraintDefinition | MaxValueFieldConstraintDefinition | SingleLineFieldConstraintDefinition | NoWhitespaceFieldConstraintDefinition | UniqueEditFieldConstraintDefinition | MaxLengthConstraintDefinition;
+export declare function createFieldConstraintDefinition(type: FieldConstraintType, value?: number, reason?: string): FieldConstraintDefinition;
+export declare function minMaxFieldConstraintValidator(val: unknown): val is FieldConstraintType.MIN_VALUE | FieldConstraintType.MAX_VALUE | FieldConstraintType.MAX_LENGTH;
+export declare const isFieldConstraintDefinition: (x: unknown) => x is {
+    type?: FieldConstraintType | undefined;
+} & {
+    type: FieldConstraintType;
+} & (import("..").DestructureGuardedTypeObj<{
+    type: typeof minMaxFieldConstraintValidator;
+    value: typeof isNumber;
+}> | import("..").DestructureGuardedTypeObj<{
+    type: (x: unknown) => x is FieldConstraintType.REQUIRED | FieldConstraintType.LOCKED | FieldConstraintType.SINGLE_LINE_ONLY | FieldConstraintType.NO_WHITESPACE | FieldConstraintType.UNIQUE_EDIT;
+    value: typeof isUndefined;
+}>);
+/** @ignore */
+export declare function serializeFieldConstraintDefinition(constraint: FieldConstraintDefinition): SerializedFieldConstraint;

package/data/fieldconstraintdefinition.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeFieldConstraintDefinition = exports.isFieldConstraintDefinition = exports.minMaxFieldConstraintValidator = exports.createFieldConstraintDefinition = void 0;
+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");
+function createFieldConstraintDefinition(type, value, reason) {
+    switch (type) {
+        case serializedfielddefinition_1.FieldConstraintType.REQUIRED:
+        case serializedfielddefinition_1.FieldConstraintType.LOCKED:
+            return Object.assign({ type }, (reason && { reason }));
+        case serializedfielddefinition_1.FieldConstraintType.MIN_VALUE:
+        case serializedfielddefinition_1.FieldConstraintType.MAX_VALUE:
+        case serializedfielddefinition_1.FieldConstraintType.MAX_LENGTH:
+            if (value === undefined) {
+                throw new Error('Invalid constraint value');
+            }
+            return Object.assign({ type, value }, (reason && { reason }));
+        case serializedfielddefinition_1.FieldConstraintType.SINGLE_LINE_ONLY:
+        case serializedfielddefinition_1.FieldConstraintType.NO_WHITESPACE:
+        case serializedfielddefinition_1.FieldConstraintType.UNIQUE_EDIT:
+            if (value !== undefined) {
+                throw new Error('Invalid constraint value');
+            }
+            return Object.assign({ type }, (reason && { reason }));
+        default:
+            (0, assertnever_1.assertNever)(type);
+    }
+}
+exports.createFieldConstraintDefinition = createFieldConstraintDefinition;
+function minMaxFieldConstraintValidator(val) {
+    return (val === serializedfielddefinition_1.FieldConstraintType.MIN_VALUE ||
+        val === serializedfielddefinition_1.FieldConstraintType.MAX_VALUE ||
+        val === serializedfielddefinition_1.FieldConstraintType.MAX_LENGTH);
+}
+exports.minMaxFieldConstraintValidator = minMaxFieldConstraintValidator;
+exports.isFieldConstraintDefinition = (0, validators_1.both)((0, validators_1.objectValidator)({
+    'type': serializedfielddefinition_1.isFieldConstraintType,
+}), (0, validators_1.either)((0, validators_1.objectValidator)({ 'type': minMaxFieldConstraintValidator, 'value': checks_1.isNumber }), (0, validators_1.objectValidator)({ 'type': (0, validators_1.exclude)(serializedfielddefinition_1.isFieldConstraintType, minMaxFieldConstraintValidator), 'value': checks_1.isUndefined })));
+/** @ignore */
+function serializeFieldConstraintDefinition(constraint) {
+    return {
+        'Type': constraint.type,
+        'Details': constraint.value,
+        'Reason': constraint.reason,
+    };
+}
+exports.serializeFieldConstraintDefinition = serializeFieldConstraintDefinition;

package/data/schemadefinition.d.ts

@@ -1,64 +1,11 @@
-import { isNumber, isUndefined } from '../core/checks';
 import { FieldTypeDefinition } from '../core/data/fieldtypedefinition/fieldtypedefinition';
 import { LucidFields } from '../core/data/fieldtypedefinition/lucidfields';
 import { SemanticFields } from '../core/data/fieldtypedefinition/semanticfields';
 import { SemanticKind } from '../core/data/fieldtypedefinition/semantickind';
-import { FieldConstraintType, SerializedFieldConstraint, SerializedFieldDefinition } from '../core/data/serializedfield/serializedfielddefinition';
+import { SerializedFieldDefinition } from '../core/data/serializedfield/serializedfielddefinition';
 import { SerializedSchema } from '../core/data/serializedfield/serializedschema';
-export interface RequiredFieldConstraintDefinition {
-    type: FieldConstraintType.REQUIRED;
-    value?: undefined;
-    reason?: string | undefined;
-}
-export interface LockedFieldConstraintDefinition {
-    type: FieldConstraintType.LOCKED;
-    value?: undefined;
-    reason?: string | undefined;
-}
-export interface MinValueFieldConstraintDefinition {
-    type: FieldConstraintType.MIN_VALUE;
-    value: number;
-    reason?: string | undefined;
-}
-export interface MaxValueFieldConstraintDefinition {
-    type: FieldConstraintType.MAX_VALUE;
-    value: number;
-    reason?: string | undefined;
-}
-export interface SingleLineFieldConstraintDefinition {
-    type: FieldConstraintType.SINGLE_LINE_ONLY;
-    value?: undefined;
-    reason?: string | undefined;
-}
-export interface NoWhitespaceFieldConstraintDefinition {
-    type: FieldConstraintType.NO_WHITESPACE;
-    value?: undefined;
-    reason?: string | undefined;
-}
-export interface UniqueEditFieldConstraintDefinition {
-    type: FieldConstraintType.UNIQUE_EDIT;
-    value?: undefined;
-    reason?: string | undefined;
-}
-export interface MaxLengthConstraintDefinition {
-    type: FieldConstraintType.MAX_LENGTH;
-    value: number;
-    reason?: string | undefined;
-}
-export type FieldConstraintDefinition = RequiredFieldConstraintDefinition | LockedFieldConstraintDefinition | MinValueFieldConstraintDefinition | MaxValueFieldConstraintDefinition | SingleLineFieldConstraintDefinition | NoWhitespaceFieldConstraintDefinition | UniqueEditFieldConstraintDefinition | MaxLengthConstraintDefinition;
-export declare function createFieldConstraintDefinition(type: FieldConstraintType, value?: number, reason?: string): FieldConstraintDefinition;
-export declare function minMaxFieldConstraintValidator(val: unknown): val is FieldConstraintType.MIN_VALUE | FieldConstraintType.MAX_VALUE | FieldConstraintType.MAX_LENGTH;
-export declare const isFieldConstraintDefinition: (x: unknown) => x is {
-    type?: FieldConstraintType | undefined;
-} & {
-    type: FieldConstraintType;
-} & (import("..").DestructureGuardedTypeObj<{
-    type: typeof minMaxFieldConstraintValidator;
-    value: typeof isNumber;
-}> | import("..").DestructureGuardedTypeObj<{
-    type: (x: unknown) => x is FieldConstraintType.REQUIRED | FieldConstraintType.LOCKED | FieldConstraintType.SINGLE_LINE_ONLY | FieldConstraintType.NO_WHITESPACE | FieldConstraintType.UNIQUE_EDIT;
-    value: typeof isUndefined;
-}>);
+import { DisplayOptionDefinition } from './displayoptiondefinition';
+import { FieldConstraintDefinition } from './fieldconstraintdefinition';
 /**
  * The definition for a field to be included in a [SchemaDefinition](#interfaces_data_schemadefinition-SchemaDefinition)
  */
@@ -67,6 +14,13 @@ export interface FieldDefinition {
     type: FieldTypeDefinition;
     constraints?: FieldConstraintDefinition[] | undefined;
     mapping?: readonly LucidFields[] | readonly SemanticFields[] | readonly SemanticKind[] | undefined;
+    /**
+     * @experimental
+     * If specified, a list of options indicating how the field should be displayed
+     * in the UI. This is particularly useful when collection enums are of a certain
+     * data type that should be rendered differently.
+     */
+    displayOptions?: readonly DisplayOptionDefinition[] | undefined;
 }
 /**
  * Definition of a schema for creating a [Collection](#classes_data_collectionproxy-CollectionProxy)
@@ -85,8 +39,6 @@ export interface SchemaDefinition {
     fieldLabels?: Record<string, string>;
 }
 /** @ignore */
-export declare function serializeFieldConstraintDefinition(constraint: FieldConstraintDefinition): SerializedFieldConstraint;
-/** @ignore */
 export declare function serializeFieldDefinition(field: FieldDefinition): SerializedFieldDefinition;
 /** @ignore */
 export declare function serializeSchemaDefinition(def: SchemaDefinition): SerializedSchema;

package/data/schemadefinition.js

@@ -1,53 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseSchemaDefinition = exports.parseFieldDefinition = exports.serializeSchemaDefinition = exports.serializeFieldDefinition = exports.serializeFieldConstraintDefinition = exports.isFieldConstraintDefinition = exports.minMaxFieldConstraintValidator = exports.createFieldConstraintDefinition = void 0;
-const assertnever_1 = require("../core/assertnever");
+exports.parseSchemaDefinition = exports.parseFieldDefinition = exports.serializeSchemaDefinition = exports.serializeFieldDefinition = void 0;
 const checks_1 = require("../core/checks");
 const fieldtypedefinition_1 = require("../core/data/fieldtypedefinition/fieldtypedefinition");
+const serializeddisplayoption_1 = require("../core/data/serializedfield/serializeddisplayoption");
 const serializedfielddefinition_1 = require("../core/data/serializedfield/serializedfielddefinition");
-const validators_1 = require("../core/validators/validators");
-function createFieldConstraintDefinition(type, value, reason) {
-    switch (type) {
-        case serializedfielddefinition_1.FieldConstraintType.REQUIRED:
-        case serializedfielddefinition_1.FieldConstraintType.LOCKED:
-            return Object.assign({ type }, (reason && { reason }));
-        case serializedfielddefinition_1.FieldConstraintType.MIN_VALUE:
-        case serializedfielddefinition_1.FieldConstraintType.MAX_VALUE:
-        case serializedfielddefinition_1.FieldConstraintType.MAX_LENGTH:
-            if (value === undefined) {
-                throw new Error('Invalid constraint value');
-            }
-            return Object.assign({ type, value }, (reason && { reason }));
-        case serializedfielddefinition_1.FieldConstraintType.SINGLE_LINE_ONLY:
-        case serializedfielddefinition_1.FieldConstraintType.NO_WHITESPACE:
-        case serializedfielddefinition_1.FieldConstraintType.UNIQUE_EDIT:
-            if (value !== undefined) {
-                throw new Error('Invalid constraint value');
-            }
-            return Object.assign({ type }, (reason && { reason }));
-        default:
-            (0, assertnever_1.assertNever)(type);
-    }
-}
-exports.createFieldConstraintDefinition = createFieldConstraintDefinition;
-function minMaxFieldConstraintValidator(val) {
-    return (val === serializedfielddefinition_1.FieldConstraintType.MIN_VALUE ||
-        val === serializedfielddefinition_1.FieldConstraintType.MAX_VALUE ||
-        val === serializedfielddefinition_1.FieldConstraintType.MAX_LENGTH);
-}
-exports.minMaxFieldConstraintValidator = minMaxFieldConstraintValidator;
-exports.isFieldConstraintDefinition = (0, validators_1.both)((0, validators_1.objectValidator)({
-    'type': serializedfielddefinition_1.isFieldConstraintType,
-}), (0, validators_1.either)((0, validators_1.objectValidator)({ 'type': minMaxFieldConstraintValidator, 'value': checks_1.isNumber }), (0, validators_1.objectValidator)({ 'type': (0, validators_1.exclude)(serializedfielddefinition_1.isFieldConstraintType, minMaxFieldConstraintValidator), 'value': checks_1.isUndefined })));
-/** @ignore */
-function serializeFieldConstraintDefinition(constraint) {
-    return {
-        'Type': constraint.type,
-        'Details': constraint.value,
-        'Reason': constraint.reason,
-    };
-}
-exports.serializeFieldConstraintDefinition = serializeFieldConstraintDefinition;
+const displayoptiondefinition_1 = require("./displayoptiondefinition");
+const fieldconstraintdefinition_1 = require("./fieldconstraintdefinition");
 /** @ignore */
 function serializeFieldDefinition(field) {
     const serialized = {
@@ -55,7 +14,10 @@ function serializeFieldDefinition(field) {
         'Type': (0, fieldtypedefinition_1.serializeFieldTypeDefinition)(field.type),
     };
     if (field.constraints) {
-        serialized['Constraints'] = field.constraints.map(serializeFieldConstraintDefinition);
+        serialized['Constraints'] = field.constraints.map(fieldconstraintdefinition_1.serializeFieldConstraintDefinition);
+    }
+    if (field.displayOptions) {
+        serialized['DisplayOptions'] = field.displayOptions.map(displayoptiondefinition_1.serializeDisplayOptionDefinition);
     }
     if (field.mapping) {
         serialized['Mapping'] = field.mapping;
@@ -74,7 +36,7 @@ function serializeSchemaDefinition(def) {
 exports.serializeSchemaDefinition = serializeSchemaDefinition;
 /** @ignore */
 function parseFieldDefinition(field) {
-    var _a;
+    var _a, _b;
     return {
         name: field['Name'],
         type: (0, fieldtypedefinition_1.deserializeFieldTypeDefinition)(field['Type']),
@@ -103,6 +65,14 @@ function parseFieldDefinition(field) {
             }
         }),
         mapping: field['Mapping'],
+        displayOptions: (_b = field['DisplayOptions']) === null || _b === void 0 ? void 0 : _b.map((option) => {
+            switch (option['Type']) {
+                case serializeddisplayoption_1.DisplayOptionType.DisplayMultiUserSelect:
+                    return { type: option['Type'] };
+                default:
+                    throw new Error('Invalid display option format');
+            }
+        }),
     };
 }
 exports.parseFieldDefinition = parseFieldDefinition;

package/dataconnector/dataconnector.d.ts

@@ -45,11 +45,11 @@ export declare class DataConnectorResponseError extends Error {
     constructor(message: string, response: string);
 }
 /** Used to track user collection access when EditorExtensionScope is PERSISTENT_SYNC. */
-export interface DocumentCollectionsBody {
+export interface AffectedDocumentCollectionsBody {
     /** A mapping from collection IDs to item IDs indicating what was affected (e.g. imported, refreshed, updated) by the action. */
-    documentCollections?: DocumentCollections;
+    affectedDocumentCollections?: DocumentCollections;
 }
-type ActionTypeForName<P extends Patch, Name extends string, Asynchronous = boolean> = Name extends `${DataConnectorActionKeys.Patch}` ? ActionRequest<DataConnectorPatchAction<P>, PatchChange[]> : Name extends `${DataConnectorActionKeys.UnbatchedPatch}` ? ActionRequest<DataConnectorPatchAction<P>, PatchChange[]> : Name extends `${DataConnectorActionKeys.ManageWebhook}` ? ActionRequest<DataConnectorManageWebhookAction, Webhook> : ActionRequest<Asynchronous extends true ? DataConnectorAsynchronousAction : DataConnectorAction, unknown | DocumentCollectionsBody>;
+type ActionTypeForName<P extends Patch, Name extends string, Asynchronous = boolean> = Name extends `${DataConnectorActionKeys.Patch}` ? ActionRequest<DataConnectorPatchAction<P>, PatchChange[]> : Name extends `${DataConnectorActionKeys.UnbatchedPatch}` ? ActionRequest<DataConnectorPatchAction<P>, PatchChange[]> : Name extends `${DataConnectorActionKeys.ManageWebhook}` ? ActionRequest<DataConnectorManageWebhookAction, Webhook> : ActionRequest<Asynchronous extends true ? DataConnectorAsynchronousAction : DataConnectorAction, unknown | AffectedDocumentCollectionsBody>;
 /** Factory class to define a bunch of action handlers. */
 export declare class DataConnector<P extends Patch = ItemPatch> {
     private client;

package/dataconnector/datasourceupdatetypes.d.ts

@@ -6,12 +6,14 @@ import { SerializedFieldTypeDefinition } from '../core/data/fieldtypedefinition/
 import { LucidFields } from '../core/data/fieldtypedefinition/lucidfields';
 import { SemanticFields } from '../core/data/fieldtypedefinition/semanticfields';
 import { SemanticKind } from '../core/data/fieldtypedefinition/semantickind';
+import { DisplayOptionType } from '../core/data/serializedfield/serializeddisplayoption';
 import { FieldConstraintType } from '../core/data/serializedfield/serializedfielddefinition';
 import { SerializedFields, SerializedLucidDictionary } from '../core/data/serializedfield/serializedfields';
 import { SerializedLabelOverrides } from '../core/data/serializedfield/serializedschema';
 import { UnsafeJsonSerializableOrUndefined } from '../core/jsonserializable';
 import { DataUpdateFilterType } from '../data/dataupdatefiltertype';
-import { FieldConstraintDefinition, FieldDefinition, SchemaDefinition } from '../data/schemadefinition';
+import { FieldConstraintDefinition } from '../data/fieldconstraintdefinition';
+import { FieldDefinition, SchemaDefinition } from '../data/schemadefinition';
 /**
  * Container for an update to a data source
  */
@@ -37,12 +39,17 @@ export type SerializedFieldConstraintForApi = {
     'details'?: UnsafeJsonSerializableOrUndefined;
     'reason'?: string | undefined;
 };
+export type SerializedDisplayOptionForApi = {
+    'type': DisplayOptionType;
+    'details'?: UnsafeJsonSerializableOrUndefined;
+};
 type SerializedFieldDefinitionForApi = {
     'name': string;
     'type': SerializedFieldTypeDefinition;
     'constraints': SerializedFieldConstraintForApi[];
     'syncSchema'?: string;
     'mapping'?: readonly SemanticKind[] | readonly LucidFields[] | readonly SemanticFields[];
+    'displayOptions'?: SerializedDisplayOptionForApi[];
 };
 export type SerializedSchemaForApi = {
     'fields': SerializedFieldDefinitionForApi[];

package/dataconnector/datasourceupdatetypes.js

@@ -74,20 +74,27 @@ function serializeFieldConstraintForApi(constraint) {
         'reason': constraint.reason,
     };
 }
+function serializeDisplayOptionForApi(option) {
+    return {
+        'type': option.type,
+        'details': option.value,
+    };
+}
 /** @ignore */
 function serializeFieldDefinitionForApi(field) {
-    var _a;
+    var _a, _b, _c;
     return {
         'name': field.name,
         'type': (0, fieldtypedefinition_1.serializeFieldTypeDefinition)(field.type),
-        'constraints': ((_a = field.constraints) !== null && _a !== void 0 ? _a : []).map((x) => serializeFieldConstraintForApi(x)),
+        'constraints': (_b = (_a = field.constraints) === null || _a === void 0 ? void 0 : _a.map(serializeFieldConstraintForApi)) !== null && _b !== void 0 ? _b : [],
         'mapping': field.mapping,
+        'displayOptions': (_c = field.displayOptions) === null || _c === void 0 ? void 0 : _c.map(serializeDisplayOptionForApi),
     };
 }
 exports.serializeFieldDefinitionForApi = serializeFieldDefinitionForApi;
 function serializeSchemaForApi(schema) {
     return {
-        'fields': schema.fields.map((x) => serializeFieldDefinitionForApi(x)),
+        'fields': schema.fields.map(serializeFieldDefinitionForApi),
         'primaryKey': schema.primaryKey,
         'fieldLabelOverrides': schema.fieldLabels,
     };
@@ -174,3 +181,4 @@ const assertIsJustRenamed = () => undefined;
 assertIsJustRenamed();
 assertIsJustRenamed();
 assertIsJustRenamed();
+assertIsJustRenamed();

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "lucid-extension-sdk",
-    "version": "0.0.433",
+    "version": "0.0.435",
     "description": "Utility classes for writing Lucid Software editor extensions",
     "main": "index.js",
     "types": "index.d.ts",