lucid-extension-sdk 0.0.305 → 0.0.307

package/commandtypes.d.ts

@@ -25,6 +25,7 @@ import { PanelLocation } from './ui/panel';
  * Before you add a new command bring it up in #api-committee to get feedback.
  */
 export declare const enum CommandName {
+    AddAuthorizationFlowHandler = "aafh",
     AddCardIntegration = "aci",
     AddDiagramFromMermaid = "adfm",
     AddDiagramFromText = "adft",
@@ -166,6 +167,10 @@ export declare const commandTitles: Map<CommandName, string>;
  * IMPORTANT - Before you add a new command bring it up in #api-committee to get feedback
  */
 export type CommandArgs = {
+    [CommandName.AddAuthorizationFlowHandler]: {
+        query: AddAuthorizationFlowHandlerQuery;
+        result: AddAuthorizationFlowHandlerResult;
+    };
     [CommandName.AddCardIntegration]: {
         query: AddCardIntegrationQuery;
         result: AddCardIntegrationResult;
@@ -687,6 +692,22 @@ export type CommandArgs = {
         result: ZOrderResult;
     };
 };
+export type AuthorizationFlowHandlerProvider = string;
+export declare enum AuthorizationFlowHandlerStage {
+    OnFailure = "onFailure"
+}
+export type AddAuthorizationFlowHandlerQuery = {
+    /**
+     * Specifies the callback function to run when the handler is triggered.
+     * String, not a function itself; this is the name of the client's registered action hook
+     */
+    'c': string;
+    /** The name of the auth provider (as specified in the package's manifest.json) that triggers this handler. */
+    'p': AuthorizationFlowHandlerProvider;
+    /** The stage during the auth flow when this handler is triggered. */
+    's': AuthorizationFlowHandlerStage;
+};
+export type AddAuthorizationFlowHandlerResult = undefined;
 export type AddCardIntegrationQuery = {
     /** Title/name */
     'n': string;
@@ -709,7 +730,9 @@ export type AddCardIntegrationQuery = {
         /** Field name -> callback name tuples for searching for legal field values in an enum */
         'fvsc'?: [string, string][] | undefined;
     };
-    /** Show intro if user has not yet authorized this integration */
+    /** Show intro if user has not yet authorized this integration
+     *  String, not function; this is the name of the client's registered action hook
+     */
     'i'?: string | undefined;
     /** Get default config action */
     'gdc': string;

package/commandtypes.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZOrderOperation = exports.isRawSendXHRResponse = exports.MermaidDiagramType = exports.GetLLMContextType = exports.GetItemsAtSearchType = exports.GetDocumentChunksType = exports.HashAlgorithmEnum = exports.commandTitles = void 0;
+exports.ZOrderOperation = exports.isRawSendXHRResponse = exports.MermaidDiagramType = exports.GetLLMContextType = exports.GetItemsAtSearchType = exports.GetDocumentChunksType = exports.HashAlgorithmEnum = exports.AuthorizationFlowHandlerStage = exports.commandTitles = void 0;
 const checks_1 = require("./core/checks");
 /** @ignore */
 exports.commandTitles = new Map([
+    ["aafh" /* CommandName.AddAuthorizationFlowHandler */, 'AddAuthorizationFlowHandler'],
     ["aci" /* CommandName.AddCardIntegration */, 'AddCardIntegration'],
     ["adfm" /* CommandName.AddDiagramFromMermaid */, 'AddDiagramFromMermaid'],
     ["adft" /* CommandName.AddDiagramFromText */, 'AddDiagramFromText'],
@@ -129,6 +130,10 @@ exports.commandTitles = new Map([
     ["wsa" /* CommandName.WithSilentActions */, 'WithSilentActions'],
     ["z" /* CommandName.ZOrder */, 'ZOrder'],
 ]);
+var AuthorizationFlowHandlerStage;
+(function (AuthorizationFlowHandlerStage) {
+    AuthorizationFlowHandlerStage["OnFailure"] = "onFailure";
+})(AuthorizationFlowHandlerStage || (exports.AuthorizationFlowHandlerStage = AuthorizationFlowHandlerStage = {}));
 var HashAlgorithmEnum;
 (function (HashAlgorithmEnum) {
     /** Use the SHA 256 hashing algorithm */

package/core/authorizationflowhandlerregistry.d.ts

@@ -0,0 +1,16 @@
+import { AuthorizationFlowHandlerProvider, AuthorizationFlowHandlerStage } from '../commandtypes';
+import { EditorClient } from '../editorclient';
+export declare class AuthorizationFlowHandlerRegistry {
+    private static nextHookId;
+    private static nextHookName;
+    /**
+     * Register a function to be run at a given stage of the authorization flow for a provider.
+     *
+     * @param client A reference to the editor client.
+     * @param callback The function to run when the handler is triggered.
+     * @param stage The stage during the auth flow when this handler is triggered.
+     * @param provider The name of the auth provider (as specified in the package's manifest.json)
+     * that triggers this handler.
+     */
+    static registerAuthorizationFlowHandler(client: EditorClient, callback: () => void, stage: AuthorizationFlowHandlerStage, provider: AuthorizationFlowHandlerProvider): void;
+}

package/core/authorizationflowhandlerregistry.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthorizationFlowHandlerRegistry = void 0;
+class AuthorizationFlowHandlerRegistry {
+    static nextHookName() {
+        return '__authorizationflow__hook' + AuthorizationFlowHandlerRegistry.nextHookId++;
+    }
+    /**
+     * Register a function to be run at a given stage of the authorization flow for a provider.
+     *
+     * @param client A reference to the editor client.
+     * @param callback The function to run when the handler is triggered.
+     * @param stage The stage during the auth flow when this handler is triggered.
+     * @param provider The name of the auth provider (as specified in the package's manifest.json)
+     * that triggers this handler.
+     */
+    static registerAuthorizationFlowHandler(client, callback, stage, provider) {
+        const actionHookName = AuthorizationFlowHandlerRegistry.nextHookName();
+        client.registerAction(actionHookName, callback);
+        const serialized = {
+            'c': actionHookName,
+            's': stage,
+            'p': provider,
+        };
+        client.sendCommand("aafh" /* CommandName.AddAuthorizationFlowHandler */, serialized);
+    }
+}
+exports.AuthorizationFlowHandlerRegistry = AuthorizationFlowHandlerRegistry;
+AuthorizationFlowHandlerRegistry.nextHookId = 0;

package/core/cardintegration/lucidcardintegration.d.ts

@@ -63,8 +63,8 @@ export declare abstract class LucidCardIntegration {
         fieldValueSearchCallbacks?: Map<string, string>;
     };
     /**
-     * If specified, and the user hasn't yet authorized the data connector for this extension,
-     * this should show the user an intro dialog or take some other action.
+     * @deprecated Use AuthorizationFlowHandlerRegistry.registerAuthorizationFlowHandler.
+     * WARNING: Currently unused and does nothing.
      */
     showIntro?: () => void;
     /**

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,72 @@
+/**
+ * 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"
+}
+export declare const isLucidFields: (x: unknown) => x is LucidFields;

package/core/data/fieldtypedefinition/lucidfields.js

@@ -0,0 +1,77 @@
+"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";
+})(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.305",
+    "version": "0.0.307",
     "description": "Utility classes for writing Lucid Software editor extensions",
     "main": "index.js",
     "types": "index.d.ts",