lucid-extension-sdk 0.0.434 → 0.0.436

package/commandtypes.d.ts

@@ -46,6 +46,7 @@ export declare const enum CommandName {
     CalculateHash = "hsh",
     CanEditPackageSettings = "ceps",
     CancelDragBlockToCanvas = "cdc",
+    CheckUserFlagAssignment = "cufa",
     Confirm = "c",
     CreateBlock = "cb",
     CreateCards = "ca",
@@ -77,6 +78,7 @@ export declare const enum CommandName {
     GetCurrentPage = "gcp",
     GetCustomShape = "gcs",
     GetDataItemField = "gdif",
+    GetDeveloperModeStatus = "gdms",
     GetDocumentAccessPermission = "gdap",
     GetDocumentChunks = "gdc",
     GetDocumentId = "gdid",
@@ -252,6 +254,10 @@ export type CommandArgs = {
         query: CancelDragBlockToCanvasQuery;
         result: CancelDragBlockToCanvasResult;
     };
+    [CommandName.CheckUserFlagAssignment]: {
+        query: CheckUserFlagAssignmentQuery;
+        result: CheckUserFlagAssignmentResult;
+    };
     [CommandName.Confirm]: {
         query: ConfirmQuery;
         result: ConfirmResult;
@@ -376,6 +382,10 @@ export type CommandArgs = {
         query: GetDataItemFieldQuery;
         result: GetDataItemFieldResult;
     };
+    [CommandName.GetDeveloperModeStatus]: {
+        query: GetDeveloperModeStatusQuery;
+        result: GetDeveloperModeStatusResult;
+    };
     [CommandName.GetDocumentAccessPermission]: {
         query: GetDocumentAccessPermissionQuery;
         result: GetDocumentAccessPermissionResult;
@@ -735,6 +745,11 @@ export type AddCardsActions = {
     /** Create card action */
     'cc': string;
 };
+export type AutoSyncSettings = {
+    'h': string;
+    'gsf': string;
+    'sqs'?: string | undefined;
+};
 export type SerializedFieldConfiguration = {
     /** Callback to get field definitions for all fields supported by the card integration */
     'gf': string;
@@ -799,6 +814,8 @@ export type AddCardIntegrationQuery = {
     } | undefined;
     /** If specified, add-card settings */
     'ac'?: AddCardsActions | undefined;
+    /** If specified, auto sync settings */
+    'as'?: AutoSyncSettings | undefined;
     /** Whether to enable dependency mapping for this integration */
     'sdm'?: boolean;
     /**
@@ -884,6 +901,10 @@ export type AddCardIntegrationQuery = {
         'd': string;
         'cb': string;
     } | undefined;
+    /**
+     * whether the user has access to items
+     */
+    'hait'?: string | undefined;
 };
 export type AddCardIntegrationResult = undefined;
 /** @ignore */
@@ -1375,6 +1396,8 @@ export type GetDataItemFieldQuery = {
     'f': string;
 };
 export type GetDataItemFieldResult = SerializedFieldType;
+export type GetDeveloperModeStatusQuery = void;
+export type GetDeveloperModeStatusResult = boolean;
 export type GetDocumentAccessPermissionQuery = void;
 export type GetDocumentAccessPermissionResult = DocumentAccessPermission;
 export declare enum GetDocumentChunksType {
@@ -1990,4 +2013,9 @@ export type ZOrderQuery = {
     'o': ZOrderOperation;
 };
 export type ZOrderResult = undefined;
+export type CheckUserFlagAssignmentQuery = {
+    /** The name of the flag that will be checked */
+    'f': string;
+};
+export type CheckUserFlagAssignmentResult = boolean;
 export {};

package/commandtypes.js

@@ -23,6 +23,7 @@ exports.commandTitles = new Map([
     ["b" /* CommandName.Bootstrap */, 'Bootstrap'],
     ["ceps" /* CommandName.CanEditPackageSettings */, 'CanEditPackageSettings'],
     ["cdc" /* CommandName.CancelDragBlockToCanvas */, 'CancelDragBlockToCanvas'],
+    ["cufa" /* CommandName.CheckUserFlagAssignment */, 'CheckUserFlagAssignment'],
     ["c" /* CommandName.Confirm */, 'Confirm'],
     ["cb" /* CommandName.CreateBlock */, 'CreateBlock'],
     ["cc" /* CommandName.CreateCollection */, 'CreateCollection'],
@@ -50,6 +51,7 @@ exports.commandTitles = new Map([
     ["gcp" /* CommandName.GetCurrentPage */, 'GetCurrentPage'],
     ["gcs" /* CommandName.GetCustomShape */, 'GetCustomShape'],
     ["gdif" /* CommandName.GetDataItemField */, 'GetDataItemField'],
+    ["gdms" /* CommandName.GetDeveloperModeStatus */, 'GetDeveloperModeStatus'],
     ["gdap" /* CommandName.GetDocumentAccessPermission */, 'GetDocumentAccessPermission'],
     ["gdc" /* CommandName.GetDocumentChunks */, 'GetDocumentChunks'],
     ["gdid" /* CommandName.GetDocumentId */, 'GetDocumentId'],

package/core/cardintegration/cardintegrationautosyncconfig.d.ts

@@ -0,0 +1,23 @@
+import { SerializedFieldType } from '../data/serializedfield/serializedfields';
+import { ExtensionCardFieldDefinition, SearchResult } from '../sharedcardintegration/cardintegrationdefinitions';
+export interface CardIntegrationAutoSyncConfig {
+    /**
+     * The header to display for the integration. For example, the Jira integration displays "JQL query sync"
+     */
+    header: string;
+    /**
+     * Callback that should return a single field that users can use to determine which instance, workspace,
+     * organization (or any equivalent field for an extension) so that the data source id can be caluclated
+     *
+     * The value is the syncDataSourceIdNonce. If this is the same no matter what, return a single ExtensionCardField
+     * with a single ExtensionCardFieldOption in ExtensionCardField.options
+     */
+    getSyncDataSourceIdField: (searchSoFar: Map<string, SerializedFieldType>) => Promise<ExtensionCardFieldDefinition[]>;
+    /**
+     * Perform a search on the query string. This should support pagination.
+     *
+     * The syncDataSourceIdNonce is provided in otherFields
+     * @returns either an error AutoSyncError or an array of issues / tasks / cards represented as an AutoSyncRow
+     */
+    searchQueryString?: (queryString: string, otherFields: Map<string, SerializedFieldType>, pageNumber: number, nextPageToken: string | undefined) => Promise<SearchResult>;
+}

package/core/cardintegration/cardintegrationautosyncconfig.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/core/cardintegration/cardintegrationparams.d.ts

@@ -23,6 +23,12 @@ export interface SearchParam {
     'o': number;
     'l': number;
 }
+export interface QuerySearchParam {
+    'qs': string;
+    'of': [string, SerializedFieldType][];
+    'pn': number;
+    'npt': string | undefined;
+}
 /** @ignore */
 export interface ImportParam {
     'pks': string[];
@@ -90,4 +96,9 @@ export interface FieldLabelIconsCallbackParam {
 export interface ImportFromSerializedFieldsCallbackParam {
     'sf': SerializedFields[];
 }
+/** @ignore */
+export interface HasAccessToItemsParam {
+    'ek': string;
+    'dk'?: string;
+}
 export {};

package/core/cardintegration/carduseraccessresult.d.ts

@@ -0,0 +1,18 @@
+import { SerializedFieldConstraint } from '../data/serializedfield/serializedfielddefinition';
+/**
+ * Defines whether the current user has access to an item.
+ */
+export interface CardUserAccessResult {
+    hasPermission: boolean;
+    constraints: {
+        fieldName: string;
+        constraints?: SerializedFieldConstraint[];
+    }[];
+}
+export declare function serializeCardUserAccessResult(result: CardUserAccessResult): {
+    hp: boolean;
+    c: {
+        fn: string;
+        cs: SerializedFieldConstraint[] | undefined;
+    }[];
+};

package/core/cardintegration/carduseraccessresult.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeCardUserAccessResult = void 0;
+function serializeCardUserAccessResult(result) {
+    return {
+        'hp': result.hasPermission,
+        'c': result.constraints.map((c) => ({
+            'fn': c.fieldName,
+            'cs': c.constraints,
+        })),
+    };
+}
+exports.serializeCardUserAccessResult = serializeCardUserAccessResult;

package/core/cardintegration/lucidcardintegration.d.ts

@@ -7,7 +7,9 @@ import { SerializedFieldType, SerializedFields } from '../data/serializedfield/s
 import { ImportCardFromDetails } from '../importcardfromdetails/importcardfromdetails';
 import { ImportCardFromPastedLinkCallback } from '../importcardfrompastedlink/importcardfrompastedlinkcallback';
 import { DependenciesForItems, ExtensionCardFieldDefinition, ExtensionFieldConfiguration, ImportResult } from '../sharedcardintegration/cardintegrationdefinitions';
+import { CardIntegrationAutoSyncConfig } from './cardintegrationautosyncconfig';
 import { CardIntegrationConfig } from './cardintegrationconfig';
+import { CardUserAccessResult } from './carduseraccessresult';
 import { DependencyMappingPhrasesType } from './dependencymappingphrases';
 import { LucidCardIntegrationCustomImportModal } from './lucidcardintegrationcustomimportmodal';
 import { LucidCardIntegrationStandardImportModal } from './lucidcardintegrationstandardimportmodal';
@@ -115,6 +117,10 @@ export declare abstract class LucidCardIntegration {
             primaryKey: string;
         }>;
     };
+    /**
+     * If specified, allows the user to use query to sync with timelines.
+     */
+    autoSync?: CardIntegrationAutoSyncConfig;
     showCardImport(name: string): import("../../commandtypes").ImportCardsResult;
     showDependencyMapping?: boolean;
     /**
@@ -143,4 +149,8 @@ export declare abstract class LucidCardIntegration {
      * the import.
      */
     importFromSerializedFields?: (data: SerializedFields[]) => Promise<ImportCardFromDetails>;
+    /**
+     * @experimental When defined, allows the extension to make cards that the user doesn't have access to view-only.
+     */
+    hasAccessToItems?: (editedKey: string, dependencyKey: string | undefined) => Promise<CardUserAccessResult>;
 }

package/core/cardintegration/lucidcardintegrationregistry.js

@@ -10,6 +10,7 @@ const checks_1 = require("../checks");
 const importcardfromdetails_1 = require("../importcardfromdetails/importcardfromdetails");
 const cardintegrationdefinitions_1 = require("../sharedcardintegration/cardintegrationdefinitions");
 const cardintegrationconfig_1 = require("./cardintegrationconfig");
+const carduseraccessresult_1 = require("./carduseraccessresult");
 const lucidcardintegrationcustomimportmodal_1 = require("./lucidcardintegrationcustomimportmodal");
 class LucidCardIntegrationRegistry {
     static nextHookName() {
@@ -172,6 +173,7 @@ class LucidCardIntegrationRegistry {
                 },
             })),
             'ipsr': searchResult.itemsPerSearchResult,
+            'e': searchResult.error,
         };
     }
     static registerImportCardFromPastedLinkHandler(client, cardIntegration, serialized) {
@@ -341,6 +343,33 @@ class LucidCardIntegrationRegistry {
                 };
             });
         }
+        if (cardIntegration.autoSync) {
+            const autoSync = cardIntegration.autoSync;
+            serialized['as'] = {
+                'h': autoSync.header,
+                'gsf': LucidCardIntegrationRegistry.nextHookName(),
+            };
+            client.registerAction(serialized['as']['gsf'], async ({ 'i': inputSoFar }) => {
+                const result = await autoSync.getSyncDataSourceIdField(new Map(inputSoFar));
+                return (0, cardintegrationdefinitions_1.serializeCardFieldArrayDefinition)(result);
+            });
+            if (autoSync.searchQueryString) {
+                serialized['as']['sqs'] = LucidCardIntegrationRegistry.nextHookName();
+                client.registerAction(serialized['as']['sqs'], async ({ 'qs': queryString, 'of': otherFields, 'pn': pageNumber, 'npt': nextPageToken, }) => {
+                    var _a;
+                    const result = await ((_a = autoSync.searchQueryString) === null || _a === void 0 ? void 0 : _a.call(autoSync, queryString, new Map(otherFields), pageNumber, nextPageToken));
+                    if (result) {
+                        return this.serializeSearchResult(result);
+                    }
+                    else {
+                        return this.serializeSearchResult({
+                            searchResults: [],
+                            error: 'Unknown Error Occurred',
+                        });
+                    }
+                });
+            }
+        }
         if (cardIntegration.fieldConfiguration.customFieldDisplaySettings) {
             serialized['fc']['cfds'] = {
                 'd': cardIntegration.fieldConfiguration.customFieldDisplaySettings.defaultToMultilineText,
@@ -358,6 +387,14 @@ class LucidCardIntegrationRegistry {
                 return (0, importcardfromdetails_1.serializeImportCardFromDetails)(result);
             });
         }
+        if (cardIntegration.hasAccessToItems) {
+            const hasAccessToItemsActionName = LucidCardIntegrationRegistry.nextHookName();
+            serialized['hait'] = hasAccessToItemsActionName;
+            client.registerAction(hasAccessToItemsActionName, async ({ 'ek': editedKey, 'dk': dependencyKey }) => {
+                const result = await cardIntegration.hasAccessToItems(editedKey, dependencyKey);
+                return (0, carduseraccessresult_1.serializeCardUserAccessResult)(result);
+            });
+        }
         client.sendCommand("aci" /* CommandName.AddCardIntegration */, serialized);
     }
 }

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/lucidicon.d.ts

@@ -1,10 +1,10 @@
-import { SerializedLucidDictionary } from './serializedfield/serializedfields';
+import { SerializedLucidIconData } from './serializedfield/serializedfields';
 /**
- * Creates icon data as a SerializedLucidDictionary.
+ * Creates icon data as a SerializedLucidIconData.
  * Useful for creating icons in extensions built on the Lucid Extension SDK that need to be parsed by Lucid's products.
  * @param icon - The URL or SVG data for the icon
  * @param ariaLabel - The accessible label for the icon
  * @param tooltipLabel - Optional tooltip text
- * @returns A SerializedLucidDictionary with the keys: icon, ariaLabel, and tooltipLabel (if provided)
+ * @returns A SerializedLucidIconData with the keys: icon, ariaLabel, and tooltipLabel (if provided)
  */
-export declare function createLucidIconData(icon: string, ariaLabel: string, tooltipLabel?: string): SerializedLucidDictionary;
+export declare function createLucidIconData(icon: string, ariaLabel: string, tooltipLabel?: string): SerializedLucidIconData;

package/core/data/lucidicon.js

@@ -2,12 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createLucidIconData = void 0;
 /**
- * Creates icon data as a SerializedLucidDictionary.
+ * Creates icon data as a SerializedLucidIconData.
  * Useful for creating icons in extensions built on the Lucid Extension SDK that need to be parsed by Lucid's products.
  * @param icon - The URL or SVG data for the icon
  * @param ariaLabel - The accessible label for the icon
  * @param tooltipLabel - Optional tooltip text
- * @returns A SerializedLucidDictionary with the keys: icon, ariaLabel, and tooltipLabel (if provided)
+ * @returns A SerializedLucidIconData with the keys: icon, ariaLabel, and tooltipLabel (if provided)
  */
 function createLucidIconData(icon, ariaLabel, tooltipLabel) {
     return {

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/core/data/serializedfield/serializedfields.d.ts

@@ -139,7 +139,15 @@ export declare const isSerializedTimeObject: (subject: unknown) => subject is im
     minutes: (x: unknown) => x is number | undefined;
     seconds: (x: unknown) => x is number | undefined;
 }>;
-export declare const isSerializedLucidIconDataDictionary: (subject: unknown) => subject is import("../../guards").DestructureGuardedTypeObj<{
+export type SerializedLucidIconData = {
+    'dict': {
+        'icon': string;
+        'ariaLabel': string;
+        'tooltipLabel'?: string | undefined;
+        'roundedIcon'?: boolean | undefined;
+    };
+};
+export declare const isSerializedLucidIconData: (subject: unknown) => subject is import("../../guards").DestructureGuardedTypeObj<{
     dict: (subject: unknown) => subject is import("../../guards").DestructureGuardedTypeObj<{
         icon: typeof isString;
         ariaLabel: typeof isString;

package/core/data/serializedfield/serializedfields.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isSerializedFields = exports.isSerializedJsonFieldType = exports.isSerializedFieldType = exports.isSerializedLucidIconDataDictionary = exports.isSerializedTimeObject = exports.isSerializedLucidDateRangeObject = exports.isSerializedLucidDateObject = exports.isSerializedIsoDateObject = exports.isSerializedMillisecondsDateObject = exports.isSerializedLucidAvatarDataDictionary = exports.isSerializedLucidCurrency = exports.isSerializedLucidDictionary = exports.isJsonSerializedLucidDictionary = exports.isNestedSerializedLucidDictionary = exports.isSerializedColorObjectFieldType = void 0;
+exports.isSerializedFields = exports.isSerializedJsonFieldType = exports.isSerializedFieldType = exports.isSerializedLucidIconData = exports.isSerializedTimeObject = exports.isSerializedLucidDateRangeObject = exports.isSerializedLucidDateObject = exports.isSerializedIsoDateObject = exports.isSerializedMillisecondsDateObject = exports.isSerializedLucidAvatarDataDictionary = exports.isSerializedLucidCurrency = exports.isSerializedLucidDictionary = exports.isJsonSerializedLucidDictionary = exports.isNestedSerializedLucidDictionary = exports.isSerializedColorObjectFieldType = void 0;
 const checks_1 = require("../../checks");
 const validators_1 = require("../../validators/validators");
 function isSerializedColorObjectFieldType(value) {
@@ -44,7 +44,7 @@ exports.isSerializedTimeObject = (0, validators_1.objectValidator)({
     'minutes': (0, validators_1.option)(checks_1.isNumber),
     'seconds': (0, validators_1.option)(checks_1.isNumber),
 });
-exports.isSerializedLucidIconDataDictionary = (0, validators_1.objectValidator)({
+exports.isSerializedLucidIconData = (0, validators_1.objectValidator)({
     'dict': (0, validators_1.objectValidator)({
         'icon': checks_1.isString,
         'ariaLabel': checks_1.isString,
@@ -64,7 +64,7 @@ function isSerializedFieldType(value) {
         (0, exports.isSerializedLucidDateRangeObject)(value) ||
         (0, exports.isSerializedTimeObject)(value) ||
         isSerializedColorObjectFieldType(value) ||
-        (0, exports.isSerializedLucidIconDataDictionary)(value) ||
+        (0, exports.isSerializedLucidIconData)(value) ||
         (0, exports.isSerializedLucidAvatarDataDictionary)(value));
 }
 exports.isSerializedFieldType = isSerializedFieldType;

package/core/sharedcardintegration/cardintegrationdefinitions.d.ts

@@ -7,7 +7,7 @@ import { FieldDescriptor } from '../cardintegration/lucidcardintegration';
 import { isArray, isString } from '../checks';
 import { isSerializedFieldTypeDefinition } from '../data/fieldtypedefinition/fieldtypedefinition';
 import { SerializedFieldDefinition } from '../data/serializedfield/serializedfielddefinition';
-import { SerializedFieldType, SerializedLucidDictionary, isSerializedFieldType } from '../data/serializedfield/serializedfields';
+import { SerializedFieldType, SerializedLucidIconData, isSerializedFieldType } from '../data/serializedfield/serializedfields';
 /** For fields with Option or ApiOption type, the label and value for each available option */
 export interface ExtensionCardFieldOption {
     label: string;
@@ -161,6 +161,7 @@ export interface SearchResultPerCollection {
 export interface SearchResult {
     searchResults: SearchResultPerCollection[];
     itemsPerSearchResult?: number | undefined;
+    error?: string | undefined;
 }
 export declare const isSearchResult: (subject: unknown) => subject is import("../guards").DestructureGuardedTypeObj<{
     searchResults: typeof isArray;
@@ -275,4 +276,4 @@ export type ExtensionFieldConfiguration = {
  * Maps item field names to icons that show next to the field labels in the card details panel.
  * Use the `createLucidIconData()` helper to format the icon data in this map.
  */
-export type ExtensionCardFieldLabelIcons = Map<string, SerializedLucidDictionary>;
+export type ExtensionCardFieldLabelIcons = Map<string, SerializedLucidIconData>;

package/data/branchedcollectionid.js

@@ -1,13 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.patchCollectionIdFromPossibleBranchedCollectionId = exports.branchedCollectionId = void 0;
-// LAL-1631: make sure references to this method are correct
 /** @ignore */
 function branchedCollectionId(upstreamId) {
     return upstreamId + '_b';
 }
 exports.branchedCollectionId = branchedCollectionId;
-// LAL-1631: make sure references to this method are correct
 /** @ignore */
 function patchCollectionIdFromPossibleBranchedCollectionId(branchId) {
     if (branchId && branchId.endsWith('_b')) {

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/datasourceclient.d.ts

@@ -35,6 +35,13 @@ export declare class DataSourceClient {
     getMetadata(keys: string[], prefixes?: string[]): Promise<MetadataRecord[]>;
     /** @ignore until metadata endpoints are made part of the public API */
     patchMetadata(patches: MetadataPatch[]): Promise<MetadataPatchResponse>;
+    /**
+     * @ignore as this is primarily an internal-use method.
+     * Checks the current value of the given feature flag. This cannot take into account any local overrides, and can
+     * only be used for feature flags (not other forms of AB test). This method reads feature flag values from our
+     * "frontend" selection of feature flags.
+     */
+    getFeatureFlagValue(flagName: string): Promise<boolean>;
 }
 /**
  * A version of the DataSourceClient that you can use for any automated tests of your data connector.

package/dataconnector/datasourceclient.js

@@ -204,6 +204,32 @@ class DataSourceClient {
         await (0, throwunsuccessful_1.throwUnsuccessful)(response, 'patching data source`s metadata');
         return { status: 'NoContent' };
     }
+    /**
+     * @ignore as this is primarily an internal-use method.
+     * Checks the current value of the given feature flag. This cannot take into account any local overrides, and can
+     * only be used for feature flags (not other forms of AB test). This method reads feature flag values from our
+     * "frontend" selection of feature flags.
+     */
+    async getFeatureFlagValue(flagName) {
+        const flagRequest = await this.fetchMethod(`${this.urls.main}features/frontend`, {
+            'method': 'GET',
+            'headers': {
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!flagRequest.ok) {
+            return false;
+        }
+        const response = await flagRequest.json();
+        const featureFlagResponseObjectValidator = (0, validators_1.objectValidator)({
+            featureFlags: (0, validators_1.objectOfValidator)(checks_1.isBoolean, checks_1.isString),
+        });
+        if (!featureFlagResponseObjectValidator(response)) {
+            return false;
+        }
+        const flagValue = response.featureFlags[flagName];
+        return !!flagValue;
+    }
 }
 exports.DataSourceClient = DataSourceClient;
 /**

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/editorclient.d.ts

@@ -361,6 +361,12 @@ export declare class EditorClient {
      * @hidden
      */
     protected listenToEditor(): void;
+    /**
+     * @ignore Until releasing developer mode
+     * Check to know if the editor is currently in developer mode
+     * @returns true if the editor is in developer mode, false otherwise
+     */
+    getDeveloperModeStatus(): boolean;
     /**
      * Display an alert modal to the user
      * @param text Body text to display in the alert modal
@@ -431,5 +437,12 @@ export declare class EditorClient {
      */
     /** @ignore because our documentation gets generated incorrectly for an as-yet unknown reason. It seems to refer to the HashAlgorithmEnum with an incorrect link. */
     hash(algorithm: HashAlgorithmEnum, string: string): string;
+    /**
+     * @ignore as this is primarily an internal-use method.
+     *
+     * Checks the current value of the given feature flag for the current user. This takes into
+     * account any local overrides, and can only be used for feature flags (not other forms of AB test).
+     */
+    checkUserFlagAssignment(flagName: string): boolean;
     constructor();
 }

package/editorclient.js

@@ -615,6 +615,14 @@ class EditorClient {
             return (_a = this.callbacks.get(msg['id'])) === null || _a === void 0 ? void 0 : _a(msg);
         });
     }
+    /**
+     * @ignore Until releasing developer mode
+     * Check to know if the editor is currently in developer mode
+     * @returns true if the editor is in developer mode, false otherwise
+     */
+    getDeveloperModeStatus() {
+        return this.sendCommand("gdms" /* CommandName.GetDeveloperModeStatus */, undefined);
+    }
     /**
      * Display an alert modal to the user
      * @param text Body text to display in the alert modal
@@ -723,6 +731,15 @@ class EditorClient {
     hash(algorithm, string) {
         return this.sendCommand("hsh" /* CommandName.CalculateHash */, { 'a': algorithm, 's': string });
     }
+    /**
+     * @ignore as this is primarily an internal-use method.
+     *
+     * Checks the current value of the given feature flag for the current user. This takes into
+     * account any local overrides, and can only be used for feature flags (not other forms of AB test).
+     */
+    checkUserFlagAssignment(flagName) {
+        return this.sendCommand("cufa" /* CommandName.CheckUserFlagAssignment */, { 'f': flagName });
+    }
     constructor() {
         this.nextId = 0;
         this.callbacks = new Map();

package/package.json

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