lucid-extension-sdk 0.0.306 → 0.0.308

package/core/data/fieldspecification.d.ts

@@ -2,6 +2,7 @@ import { FieldConstraintDefinition } from '../../data/schemadefinition';
 import { CollectionEnumFieldType } from './fieldtypedefinition/collectionenumfieldtype';
 import { FieldTypeArray } from './fieldtypedefinition/fieldtypearray';
 import { FieldTypeDefinition } from './fieldtypedefinition/fieldtypedefinition';
+import { LucidFields } from './fieldtypedefinition/lucidfields';
 import { ScalarFieldTypeEnum } from './fieldtypedefinition/scalarfieldtype';
 import { SemanticFields } from './fieldtypedefinition/semanticfields';
 import { SemanticKind } from './fieldtypedefinition/semantickind';
@@ -22,7 +23,7 @@ export declare function declareSchema<Names extends string, Types extends Readon
     [Name in Names]: {
         type: Types;
         constraints?: readonly Constraint[];
-        mapping?: readonly SemanticKind[] | readonly SemanticFields[] | undefined;
+        mapping?: readonly SemanticKind[] | readonly SemanticFields[] | readonly LucidFields[] | undefined;
     };
 }, PrimaryKey extends keyof Fields>({ primaryKey, fields }: {
     primaryKey: PrimaryKey[];
@@ -33,7 +34,7 @@ export declare function declareSchema<Names extends string, Types extends Readon
         name: Exclude<keyof typeof fields, number>;
         type: FieldTypeDefinition;
         constraints: FieldConstraintDefinition[];
-        mapping: readonly SemanticKind[] | readonly SemanticFields[];
+        mapping: readonly SemanticKind[] | readonly SemanticFields[] | readonly LucidFields[];
     }[];
     primaryKey: FormattedPrimaryKey<Fields, PrimaryKey>;
     fromItemsSparse: (items: PartialItemType<typeof fields, PrimaryKey>[]) => Map<string, PartialItemType<Fields, PrimaryKey>>;
@@ -80,7 +81,7 @@ export declare class FormattedPrimaryKey<Fields extends FieldsStructure, Primary
 type FieldsStructure = {
     [Name in string]: {
         type: Readonly<FieldTypeDefinition>;
-        mapping?: undefined | readonly SemanticKind[] | readonly SemanticFields[];
+        mapping?: undefined | readonly SemanticKind[] | readonly SemanticFields[] | readonly LucidFields[];
     };
 };
 /**

package/core/data/fieldtypedefinition/lucidfields.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Lucid Fields serve as standardized categories that transcend individual data source labels, facilitating
+ * a uniform way to access and manipulate data. For instance, regardless of the source, data that pertains to "titles"
+ * or "user information" often carries the same kind of information, though it may be labeled differently across systems.
+ * Lucid Fields ensure that such data is recognized and treated consistently within the platform,
+ * regardless of external labeling conventions.
+ *
+ * Semantic Mapping is the process through which Lucid aligns these disparate field names to a set of standardized
+ * Lucid Fields. By using Lucid Fields like Title, Description, User, and Project, Lucid simplifies the way
+ * users access and interact with data brought in from external sources.
+ *
+ * Benefits of Lucid Fields:
+ * Uniformity: Ensures that data from diverse sources is referenced consistently within Lucid.
+ * Integration Simplicity: Simplifies the process of integrating new data sources into Lucid by mapping to an established set of Lucid Fields.
+ * Feature Compatibility: Allows for seamless use of Lucid’s intelligent features across all data, regardless of its origin.
+ * Data Organization: Provides a structured approach to organizing and grouping data within the Lucid ecosystem.
+ */
+export declare enum LucidFields {
+    /**
+     * Represents the title or main descriptor of an item.
+     */
+    Title = "title",
+    /**
+     * Captures detailed information or a summary about an item.
+     */
+    Description = "description",
+    /**
+     * Refers to the user associated with or assigned to an item.
+     */
+    User = "user",
+    /**
+     * Specific to the reporting user, typically in the context of a ticketing system.
+     */
+    Reporter = "user.reporter",
+    /**
+     * Refers to the time associated with an item.
+     */
+    Time = "time",
+    /**
+     * Pertains to the ending or completion time of an item.
+     */
+    EndTime = "time.endtime",
+    /**
+     * Contains estimations related to items, like time or resource estimates.
+     */
+    Estimate = "estimate",
+    /**
+     * Reflects status of an item, typically in the context of a ticketing system.
+     */
+    Status = "status",
+    /**
+     * Classifies the type of issue or item, typically in the context of a ticketing system.
+     */
+    IssueType = "issuetype",
+    /**
+     * Indicates the importance or urgency level of an item.
+     */
+    Priority = "priority",
+    /**
+     * Relates to the project with which an item is associated.
+     */
+    Project = "project",
+    /**
+     * The unique URL or identifier linking back to the item’s source.
+     */
+    SourceItemUrl = "url",
+    /**
+     * Refers to the URL of the image associated with this item
+     */
+    ImageUrl = "url.image",
+    /**
+     * Represents the sprint or time interval this item is assigned to.
+     */
+    Sprint = "sprint",
+    /**
+     * Refers to the team associated with or responsible for this item.
+     */
+    Team = "team",
+    /**
+     * Refers to the parent item this item belongs to.
+     */
+    Parent = "parent"
+}
+export declare const isLucidFields: (x: unknown) => x is LucidFields;

package/core/data/fieldtypedefinition/lucidfields.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLucidFields = exports.LucidFields = void 0;
+const validators_1 = require("../../validators/validators");
+/**
+ * Lucid Fields serve as standardized categories that transcend individual data source labels, facilitating
+ * a uniform way to access and manipulate data. For instance, regardless of the source, data that pertains to "titles"
+ * or "user information" often carries the same kind of information, though it may be labeled differently across systems.
+ * Lucid Fields ensure that such data is recognized and treated consistently within the platform,
+ * regardless of external labeling conventions.
+ *
+ * Semantic Mapping is the process through which Lucid aligns these disparate field names to a set of standardized
+ * Lucid Fields. By using Lucid Fields like Title, Description, User, and Project, Lucid simplifies the way
+ * users access and interact with data brought in from external sources.
+ *
+ * Benefits of Lucid Fields:
+ * Uniformity: Ensures that data from diverse sources is referenced consistently within Lucid.
+ * Integration Simplicity: Simplifies the process of integrating new data sources into Lucid by mapping to an established set of Lucid Fields.
+ * Feature Compatibility: Allows for seamless use of Lucid’s intelligent features across all data, regardless of its origin.
+ * Data Organization: Provides a structured approach to organizing and grouping data within the Lucid ecosystem.
+ */
+var LucidFields;
+(function (LucidFields) {
+    /**
+     * Represents the title or main descriptor of an item.
+     */
+    LucidFields["Title"] = "title";
+    /**
+     * Captures detailed information or a summary about an item.
+     */
+    LucidFields["Description"] = "description";
+    /**
+     * Refers to the user associated with or assigned to an item.
+     */
+    LucidFields["User"] = "user";
+    /**
+     * Specific to the reporting user, typically in the context of a ticketing system.
+     */
+    LucidFields["Reporter"] = "user.reporter";
+    /**
+     * Refers to the time associated with an item.
+     */
+    LucidFields["Time"] = "time";
+    /**
+     * Pertains to the ending or completion time of an item.
+     */
+    LucidFields["EndTime"] = "time.endtime";
+    /**
+     * Contains estimations related to items, like time or resource estimates.
+     */
+    LucidFields["Estimate"] = "estimate";
+    /**
+     * Reflects status of an item, typically in the context of a ticketing system.
+     */
+    LucidFields["Status"] = "status";
+    /**
+     * Classifies the type of issue or item, typically in the context of a ticketing system.
+     */
+    LucidFields["IssueType"] = "issuetype";
+    /**
+     * Indicates the importance or urgency level of an item.
+     */
+    LucidFields["Priority"] = "priority";
+    /**
+     * Relates to the project with which an item is associated.
+     */
+    LucidFields["Project"] = "project";
+    /**
+     * The unique URL or identifier linking back to the item’s source.
+     */
+    LucidFields["SourceItemUrl"] = "url";
+    /**
+     * Refers to the URL of the image associated with this item
+     */
+    LucidFields["ImageUrl"] = "url.image";
+    /**
+     * Represents the sprint or time interval this item is assigned to.
+     */
+    LucidFields["Sprint"] = "sprint";
+    /**
+     * Refers to the team associated with or responsible for this item.
+     */
+    LucidFields["Team"] = "team";
+    /**
+     * Refers to the parent item this item belongs to.
+     */
+    LucidFields["Parent"] = "parent";
+})(LucidFields || (exports.LucidFields = LucidFields = {}));
+exports.isLucidFields = (0, validators_1.stringEnumValidator)(LucidFields);

package/core/data/fieldtypedefinition/semanticfields.d.ts

@@ -1,72 +1,22 @@
 /**
- * Semantic Fields serve as standardized categories that transcend individual data source labels, facilitating
- * a uniform way to access and manipulate data. For instance, regardless of the source, data that pertains to "titles"
- * or "user information" often carries the same kind of information, though it may be labeled differently across systems.
- * Lucid’s Semantic Fields ensure that such data is recognized and treated consistently within the platform,
- * regardless of external labeling conventions.
- *
- * Semantic Mapping is the process through which Lucid aligns these disparate field names to a set of standardized
- * Semantic Fields. By using Semantic Fields like Title, Description, User, and Project, Lucid simplifies the way
- * users access and interact with data brought in from external sources.
- *
- * Benefits of Semantic Fields:
- * Uniformity: Ensures that data from diverse sources is referenced consistently within Lucid.
- * Integration Simplicity: Simplifies the process of integrating new data sources into Lucid by mapping to an established set of Semantic Fields.
- * Feature Compatibility: Allows for seamless use of Lucid’s intelligent features across all data, regardless of its origin.
- * Data Organization: Provides a structured approach to organizing and grouping data within the Lucid ecosystem.
+ * @deprecated use LucidFields instead. SemanticFields has not been removed to ensure backwards compatability.
  */
 export declare enum SemanticFields {
-    /**
-     * Represents the title or main descriptor of an item.
-     */
     Title = "title",
-    /**
-     * Captures detailed information or a summary about an item.
-     */
     Description = "description",
-    /**
-     * Refers to the user associated with or assigned to an item.
-     */
     User = "user",
-    /**
-     * Specific to the reporting user, typically in the context of a ticketing system.
-     */
     Reporter = "user.reporter",
-    /**
-     * Refers to the time associated with an item.
-     */
     Time = "time",
-    /**
-     * Pertains to the ending or completion time of an item.
-     */
     EndTime = "time.endtime",
-    /**
-     * Contains estimations related to items, like time or resource estimates.
-     */
     Estimate = "estimate",
-    /**
-     * Reflects status of an item, typically in the context of a ticketing system.
-     */
     Status = "status",
-    /**
-     * Classifies the type of issue or item, typically in the context of a ticketing system.
-     */
     IssueType = "issuetype",
-    /**
-     * Indicates the importance or urgency level of an item.
-     */
     Priority = "priority",
-    /**
-     * Relates to the project with which an item is associated.
-     */
     Project = "project",
-    /**
-     * The unique URL or identifier linking back to the item’s source.
-     */
     SourceItemUrl = "url",
-    /**
-     * Refers to the URL of the image associated with this item
-     */
     ImageUrl = "url.image"
 }
+/**
+ * @deprecated use isLucidFields instead
+ */
 export declare const isSemanticFields: (x: unknown) => x is SemanticFields;

package/core/data/fieldtypedefinition/semanticfields.js

@@ -3,75 +3,25 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isSemanticFields = exports.SemanticFields = void 0;
 const validators_1 = require("../../validators/validators");
 /**
- * Semantic Fields serve as standardized categories that transcend individual data source labels, facilitating
- * a uniform way to access and manipulate data. For instance, regardless of the source, data that pertains to "titles"
- * or "user information" often carries the same kind of information, though it may be labeled differently across systems.
- * Lucid’s Semantic Fields ensure that such data is recognized and treated consistently within the platform,
- * regardless of external labeling conventions.
- *
- * Semantic Mapping is the process through which Lucid aligns these disparate field names to a set of standardized
- * Semantic Fields. By using Semantic Fields like Title, Description, User, and Project, Lucid simplifies the way
- * users access and interact with data brought in from external sources.
- *
- * Benefits of Semantic Fields:
- * Uniformity: Ensures that data from diverse sources is referenced consistently within Lucid.
- * Integration Simplicity: Simplifies the process of integrating new data sources into Lucid by mapping to an established set of Semantic Fields.
- * Feature Compatibility: Allows for seamless use of Lucid’s intelligent features across all data, regardless of its origin.
- * Data Organization: Provides a structured approach to organizing and grouping data within the Lucid ecosystem.
+ * @deprecated use LucidFields instead. SemanticFields has not been removed to ensure backwards compatability.
  */
 var SemanticFields;
 (function (SemanticFields) {
-    /**
-     * Represents the title or main descriptor of an item.
-     */
     SemanticFields["Title"] = "title";
-    /**
-     * Captures detailed information or a summary about an item.
-     */
     SemanticFields["Description"] = "description";
-    /**
-     * Refers to the user associated with or assigned to an item.
-     */
     SemanticFields["User"] = "user";
-    /**
-     * Specific to the reporting user, typically in the context of a ticketing system.
-     */
     SemanticFields["Reporter"] = "user.reporter";
-    /**
-     * Refers to the time associated with an item.
-     */
     SemanticFields["Time"] = "time";
-    /**
-     * Pertains to the ending or completion time of an item.
-     */
     SemanticFields["EndTime"] = "time.endtime";
-    /**
-     * Contains estimations related to items, like time or resource estimates.
-     */
     SemanticFields["Estimate"] = "estimate";
-    /**
-     * Reflects status of an item, typically in the context of a ticketing system.
-     */
     SemanticFields["Status"] = "status";
-    /**
-     * Classifies the type of issue or item, typically in the context of a ticketing system.
-     */
     SemanticFields["IssueType"] = "issuetype";
-    /**
-     * Indicates the importance or urgency level of an item.
-     */
     SemanticFields["Priority"] = "priority";
-    /**
-     * Relates to the project with which an item is associated.
-     */
     SemanticFields["Project"] = "project";
-    /**
-     * The unique URL or identifier linking back to the item’s source.
-     */
     SemanticFields["SourceItemUrl"] = "url";
-    /**
-     * Refers to the URL of the image associated with this item
-     */
     SemanticFields["ImageUrl"] = "url.image";
 })(SemanticFields || (exports.SemanticFields = SemanticFields = {}));
+/**
+ * @deprecated use isLucidFields instead
+ */
 exports.isSemanticFields = (0, validators_1.stringEnumValidator)(SemanticFields);

package/core/data/fieldtypedefinition/semantickind.d.ts

@@ -1,6 +1,7 @@
+import { LucidFields } from './lucidfields';
 import { SemanticFields } from './semanticfields';
 /**
- * @deprecated use SemanticFields instead. SemanticKind has not been removed to ensure backwards compatability.
+ * @deprecated use LucidFields instead. SemanticKind has not been removed to ensure backwards compatability.
  */
 export declare enum SemanticKind {
     Id = "id",
@@ -22,4 +23,8 @@ export declare enum SemanticKind {
     URL = "url"
 }
 export declare const isSemanticKind: (x: unknown) => x is SemanticKind;
+export declare function semanticKindToLucidFields(semanticField: SemanticKind | SemanticFields | LucidFields): LucidFields | undefined;
+/**
+ * @deprecated use semanticKindToLucidFields instead
+ */
 export declare function semanticKindToSemanticFields(semanticField: SemanticKind | SemanticFields): SemanticFields | undefined;

package/core/data/fieldtypedefinition/semantickind.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.semanticKindToSemanticFields = exports.isSemanticKind = exports.SemanticKind = void 0;
+exports.semanticKindToSemanticFields = exports.semanticKindToLucidFields = exports.isSemanticKind = exports.SemanticKind = void 0;
 const validators_1 = require("../../validators/validators");
+const lucidfields_1 = require("./lucidfields");
 const semanticfields_1 = require("./semanticfields");
 /**
- * @deprecated use SemanticFields instead. SemanticKind has not been removed to ensure backwards compatability.
+ * @deprecated use LucidFields instead. SemanticKind has not been removed to ensure backwards compatability.
  */
 var SemanticKind;
 (function (SemanticKind) {
@@ -27,8 +28,90 @@ var SemanticKind;
     SemanticKind["URL"] = "url";
 })(SemanticKind || (exports.SemanticKind = SemanticKind = {}));
 exports.isSemanticKind = (0, validators_1.enumValidator)(SemanticKind);
+function semanticKindToLucidFields(semanticField) {
+    if ((0, lucidfields_1.isLucidFields)(semanticField)) {
+        return semanticField;
+    }
+    else if ((0, semanticfields_1.isSemanticFields)(semanticField)) {
+        switch (semanticField) {
+            case semanticfields_1.SemanticFields.Title:
+                return lucidfields_1.LucidFields.Title;
+            case semanticfields_1.SemanticFields.Description:
+                return lucidfields_1.LucidFields.Description;
+            case semanticfields_1.SemanticFields.User:
+                return lucidfields_1.LucidFields.User;
+            case semanticfields_1.SemanticFields.Reporter:
+                return lucidfields_1.LucidFields.Reporter;
+            case semanticfields_1.SemanticFields.Time:
+                return lucidfields_1.LucidFields.Time;
+            case semanticfields_1.SemanticFields.EndTime:
+                return lucidfields_1.LucidFields.EndTime;
+            case semanticfields_1.SemanticFields.Estimate:
+                return lucidfields_1.LucidFields.Estimate;
+            case semanticfields_1.SemanticFields.Status:
+                return lucidfields_1.LucidFields.Status;
+            case semanticfields_1.SemanticFields.IssueType:
+                return lucidfields_1.LucidFields.IssueType;
+            case semanticfields_1.SemanticFields.Priority:
+                return lucidfields_1.LucidFields.Priority;
+            case semanticfields_1.SemanticFields.Project:
+                return lucidfields_1.LucidFields.Project;
+            case semanticfields_1.SemanticFields.SourceItemUrl:
+                return lucidfields_1.LucidFields.SourceItemUrl;
+            case semanticfields_1.SemanticFields.ImageUrl:
+                return lucidfields_1.LucidFields.ImageUrl;
+            default:
+                return undefined;
+        }
+    }
+    else {
+        switch (semanticField) {
+            case SemanticKind.Id:
+                return undefined;
+            case SemanticKind.Title:
+                return lucidfields_1.LucidFields.Title;
+            // Name could have been mapped to User or Title but all uses cases outside of the unified viz API use it as Title
+            case SemanticKind.Name:
+                return lucidfields_1.LucidFields.Title;
+            case SemanticKind.Image:
+                return lucidfields_1.LucidFields.ImageUrl;
+            case SemanticKind.Description:
+                return lucidfields_1.LucidFields.Description;
+            case SemanticKind.Assignee:
+                return lucidfields_1.LucidFields.User;
+            case SemanticKind.Estimate:
+                return lucidfields_1.LucidFields.Estimate;
+            case SemanticKind.Status:
+                return lucidfields_1.LucidFields.Status;
+            case SemanticKind.IssueType:
+                return lucidfields_1.LucidFields.IssueType;
+            case SemanticKind.Priority:
+                return lucidfields_1.LucidFields.Priority;
+            case SemanticKind.Project:
+                return lucidfields_1.LucidFields.Project;
+            case SemanticKind.Reporter:
+                return lucidfields_1.LucidFields.Reporter;
+            case SemanticKind.StartTime:
+                return lucidfields_1.LucidFields.Time;
+            case SemanticKind.EndTime:
+                return lucidfields_1.LucidFields.EndTime;
+            case SemanticKind.GroupByHint:
+                return undefined;
+            case SemanticKind.PrimaryKeyReference:
+                return undefined;
+            case SemanticKind.URL:
+                return lucidfields_1.LucidFields.SourceItemUrl;
+            default:
+                return undefined;
+        }
+    }
+}
+exports.semanticKindToLucidFields = semanticKindToLucidFields;
+/**
+ * @deprecated use semanticKindToLucidFields instead
+ */
 function semanticKindToSemanticFields(semanticField) {
-    if ((0, semanticfields_1.isSemanticFields)(semanticField)) {
+    if ((0, lucidfields_1.isLucidFields)(semanticField)) {
         return semanticField;
     }
     else {

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

@@ -1,6 +1,7 @@
 import { isString } from '../../checks';
 import { JsonSerializable } from '../../jsonserializable';
 import { SerializedFieldTypeDefinition, isSerializedFieldTypeDefinition } from '../fieldtypedefinition/fieldtypedefinition';
+import { LucidFields } from '../fieldtypedefinition/lucidfields';
 import { SemanticFields } from '../fieldtypedefinition/semanticfields';
 import { SemanticKind } from '../fieldtypedefinition/semantickind';
 export declare enum FieldConstraintType {
@@ -27,7 +28,7 @@ export type SerializedFieldDefinition = {
     'Type': SerializedFieldTypeDefinition;
     'Constraints'?: SerializedFieldConstraint[] | undefined;
     'SyncSchema'?: string | undefined;
-    'Mapping'?: readonly SemanticFields[] | readonly SemanticKind[] | undefined;
+    'Mapping'?: readonly LucidFields[] | readonly SemanticFields[] | readonly SemanticKind[] | undefined;
 };
 export declare const isSerializedFieldDefinition: (subject: unknown) => subject is import("../../guards").DestructureGuardedTypeObj<{
     Name: typeof isString;
@@ -37,5 +38,5 @@ export declare const isSerializedFieldDefinition: (subject: unknown) => subject
         Details: (x: unknown) => x is any;
     }>[] | undefined;
     SyncSchema: (x: unknown) => x is string | undefined;
-    Mapping: (x: unknown) => x is SemanticFields[] | SemanticKind[] | undefined;
+    Mapping: (x: unknown) => x is LucidFields[] | SemanticKind[] | undefined;
 }>;

package/core/data/serializedfield/serializedfielddefinition.js

@@ -4,7 +4,7 @@ exports.isSerializedFieldDefinition = exports.isSerializedFieldConstraint = expo
 const checks_1 = require("../../checks");
 const validators_1 = require("../../validators/validators");
 const fieldtypedefinition_1 = require("../fieldtypedefinition/fieldtypedefinition");
-const semanticfields_1 = require("../fieldtypedefinition/semanticfields");
+const lucidfields_1 = require("../fieldtypedefinition/lucidfields");
 const semantickind_1 = require("../fieldtypedefinition/semantickind");
 // The options here must match com.lucidchart.data.model.fielddefinition.FieldConstraintType on the backend
 var FieldConstraintType;
@@ -28,5 +28,5 @@ exports.isSerializedFieldDefinition = (0, validators_1.strictObjectValidator)({
     'Type': fieldtypedefinition_1.isSerializedFieldTypeDefinition,
     '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)(semanticfields_1.isSemanticFields), (0, validators_1.arrayValidator)(semantickind_1.isSemanticKind))),
+    'Mapping': (0, validators_1.option)((0, validators_1.either)((0, validators_1.arrayValidator)(lucidfields_1.isLucidFields), (0, validators_1.arrayValidator)(semantickind_1.isSemanticKind))),
 });

package/data/schemadefinition.d.ts

@@ -1,5 +1,6 @@
 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';
@@ -56,7 +57,7 @@ export interface FieldDefinition {
     name: string;
     type: FieldTypeDefinition;
     constraints?: FieldConstraintDefinition[] | undefined;
-    mapping?: readonly SemanticFields[] | readonly SemanticKind[] | undefined;
+    mapping?: readonly LucidFields[] | readonly SemanticFields[] | readonly SemanticKind[] | undefined;
 }
 /**
  * Definition of a schema for creating a [Collection](#classes_data_collectionproxy-CollectionProxy)

package/dataconnector/datasourceupdatetypes.d.ts

@@ -2,6 +2,7 @@ import { SemanticCollection } from '../core/data/datasource/semanticcollection';
 import { SourceForeignKey } from '../core/data/datasource/sourceforeignkeys';
 import { UpstreamPatchType } from '../core/data/datasource/upstreampatchtype';
 import { SerializedFieldTypeDefinition } 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 } from '../core/data/serializedfield/serializedfielddefinition';
@@ -37,7 +38,7 @@ type SerializedFieldDefinitionForApi = {
     'type': SerializedFieldTypeDefinition;
     'constraints': SerializedFieldConstraintForApi[];
     'syncSchema'?: string;
-    'mapping'?: readonly SemanticKind[] | readonly SemanticFields[];
+    'mapping'?: readonly SemanticKind[] | readonly LucidFields[] | readonly SemanticFields[];
 };
 export type SerializedSchemaForApi = {
     'fields': SerializedFieldDefinitionForApi[];

package/package.json

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