lucid-extension-sdk 0.0.100 → 0.0.102

package/package.json

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

package/sdk/commandtypes.d.ts

@@ -62,6 +62,7 @@ export declare const enum CommandName {
     HideModal = "hm",
     HidePanel = "hp",
     HookCreateItems = "hci",
+    HookDeleteItems = "hdi",
     HookSelection = "hs",
     HookTextEdit = "hte",
     ImportCards = "ic",
@@ -103,6 +104,7 @@ export declare const enum CommandName {
     StartPDFUploadRequest = "pdf",
     ThrowForTestCase = "throw",
     UnhookCreateItems = "uci",
+    UnhookDeleteItems = "udi",
     UnhookSelection = "us",
     UnhookTextEdit = "ute"
 }
@@ -286,6 +288,10 @@ export declare type CommandArgs = {
         query: HookCreateItemsQuery;
         result: HookCreateItemsResult;
     };
+    [CommandName.HookDeleteItems]: {
+        query: HookDeleteItemsQuery;
+        result: HookDeleteItemsResult;
+    };
     [CommandName.HookSelection]: {
         query: HookSelectionQuery;
         result: HookSelectionResult;
@@ -450,6 +456,10 @@ export declare type CommandArgs = {
         query: UnhookCreateItemsQuery;
         result: UnhookCreateItemsResult;
     };
+    [CommandName.UnhookDeleteItems]: {
+        query: UnhookDeleteItemsQuery;
+        result: UnhookDeleteItemsResult;
+    };
     [CommandName.UnhookSelection]: {
         query: UnhookSelectionQuery;
         result: UnhookSelectionResult;
@@ -824,6 +834,11 @@ export declare type HookCreateItemsQuery = {
     'n': string;
 };
 export declare type HookCreateItemsResult = undefined;
+export declare type HookDeleteItemsQuery = {
+    /** Name of the action for receiving events. Will be called with an array of strings of all recently deleted item IDs. */
+    'n': string;
+};
+export declare type HookDeleteItemsResult = undefined;
 export declare type HookSelectionQuery = {
     /** Name of the action for receiving events. Will be called with an array of strings of all selected item IDs. */
     'n': string;
@@ -1092,6 +1107,11 @@ export declare type UnhookCreateItemsQuery = {
     'n': string;
 };
 export declare type UnhookCreateItemsResult = undefined;
+export declare type UnhookDeleteItemsQuery = {
+    /** Name of the action passed to HookDeleteItems */
+    'n': string;
+};
+export declare type UnhookDeleteItemsResult = undefined;
 export declare type UnhookSelectionQuery = {
     /** Name of the action for receiving these events */
     'n': string;

package/sdk/commandtypes.js

@@ -45,6 +45,7 @@ exports.commandTitles = new Map([
     ["hm" /* CommandName.HideModal */, 'HideModal'],
     ["hp" /* CommandName.HidePanel */, 'HidePanel'],
     ["hci" /* CommandName.HookCreateItems */, 'HookCreateItems'],
+    ["hdi" /* CommandName.HookDeleteItems */, 'HookDeleteItems'],
     ["hs" /* CommandName.HookSelection */, 'HookSelection'],
     ["hte" /* CommandName.HookTextEdit */, 'HookTextEdit'],
     ["ic" /* CommandName.ImportCards */, 'ImportCards'],
@@ -84,6 +85,7 @@ exports.commandTitles = new Map([
     ["pdf" /* CommandName.StartPDFUploadRequest */, 'StartPDFUploadRequest'],
     ["throw" /* CommandName.ThrowForTestCase */, 'ThrowForTestCase'],
     ["uci" /* CommandName.UnhookCreateItems */, 'UnhookCreateItems'],
+    ["udi" /* CommandName.UnhookDeleteItems */, 'UnhookDeleteItems'],
     ["us" /* CommandName.UnhookSelection */, 'UnhookSelection'],
     ["ute" /* CommandName.UnhookTextEdit */, 'UnhookTextEdit'],
 ]);

package/sdk/core/data/fieldspecification.d.ts

@@ -0,0 +1,104 @@
+import { FieldConstraintDefinition } from '../../data/schemadefinition';
+import { CollectionEnumFieldType } from './fieldtypedefinition/collectionenumfieldtype';
+import { FieldTypeArray } from './fieldtypedefinition/fieldtypearray';
+import { FieldTypeDefinition } from './fieldtypedefinition/fieldtypedefinition';
+import { ScalarFieldTypeEnum } from './fieldtypedefinition/scalarfieldtype';
+import { SemanticKind } from './fieldtypedefinition/semantickind';
+import { SerializedColorObject, SerializedLucidCurrency, SerializedLucidDateObject, SerializedLucidDictionary } from './serializedfield/serializedfields';
+declare type TsTypeOf<X> = X extends ScalarFieldTypeEnum.ANY ? unknown : X extends ScalarFieldTypeEnum.NUMBER ? number : X extends ScalarFieldTypeEnum.BOOLEAN ? boolean : X extends ScalarFieldTypeEnum.STRING ? string : X extends ScalarFieldTypeEnum.COLOR ? SerializedColorObject : X extends ScalarFieldTypeEnum.DATE ? SerializedLucidDateObject : X extends ScalarFieldTypeEnum.NULL ? null : X extends ScalarFieldTypeEnum.DICTIONARY ? SerializedLucidDictionary : X extends FieldTypeArray<infer Inner> ? TsTypeOf<Inner>[] : X extends ScalarFieldTypeEnum.CURRENCY ? SerializedLucidCurrency : X extends ScalarFieldTypeEnum.DATEONLY ? SerializedLucidDateObject & {
+    isDateOnly: true;
+} : X extends CollectionEnumFieldType ? string : X extends readonly [infer Inner, ...infer Others] ? TsTypeOf<Inner> | TsTypeOf<Others> : never;
+/**
+ * Specifies all the fields that this itegration will be sending to the data-sync service.
+ * Give you well typed methods to convert from `YourType[]` to `{[PrimaryKey:string]: YourType}`
+ * which is what most of the data sync service calls expect.
+ *
+ * There is fromItems which does the above will full type information, and fromItems sparse
+ * which allows all the fields not part of the primaryKey to be undefined. The former should
+ * be used with initial imports, and the latter can be used for updates.
+ */
+export declare function declareSchema<Names extends string, Types extends Readonly<FieldTypeDefinition>, Constraint extends FieldConstraintDefinition, SemanticFieldTypes extends SemanticKind, Fields extends {
+    [Name in Names]: {
+        type: Types;
+        constraints?: readonly Constraint[];
+        mapping?: readonly SemanticFieldTypes[] | undefined;
+    };
+}, PrimaryKey extends keyof Fields>({ primaryKey, fields }: {
+    primaryKey: PrimaryKey[];
+    fields: Fields;
+}): {
+    example: Fields;
+    array: {
+        name: Exclude<keyof typeof fields, number>;
+        type: FieldTypeDefinition;
+        constraints: FieldConstraintDefinition[];
+        mapping: SemanticFieldTypes[];
+    }[];
+    primaryKey: FormattedPrimaryKey<Fields, PrimaryKey>;
+    fromItemsSparse: (items: PartialItemType<typeof fields, PrimaryKey>[]) => Map<string, PartialItemType<Fields, PrimaryKey>>;
+    fromItems: (items: ItemType<typeof fields>[]) => Map<string, ItemType<Fields>>;
+};
+/**
+ * Generates a mapper that, given a primary key definition is able to produce the primary key for that item.
+ **/
+export declare class FormattedPrimaryKey<Fields extends FieldsStructure, PrimaryKey extends keyof Fields> {
+    readonly elements: PrimaryKey[];
+    constructor(...elements: PrimaryKey[]);
+    /**
+     * Generate the serialized form of the item's primary key.
+     *
+     * For single value primary keys, the encoded values are just the json representation of the primary
+     * key. For example, if the primary key is ['id'] the following table shows encodings:
+     *
+     * | type    | value     | encoded                            |
+     * |---------|-----------|------------------------------------|
+     * | number  | `15`      | `new Map([["15", ...], ...])`      |
+     * | boolean | `false`   | `new Map([["false", ...], ...])`   |
+     * | string  | `"hello"` | `new Map([['"hello"', ...], ...])` |
+     *
+     * Take note of the extra quotes in the string case.
+     *
+     * For primary keys with multiple values, first sort the array of primary keys then join the json encoded values
+     * from of the keys with commas. For example:
+     *
+     * ```
+     * primary key = ["lastName", "firstName"]
+     * sorted key = ["firstName", "lastName"]
+     * row = {"lastName": "Smith", "firstName": "John", "age": 42}
+     * row key = '"John","Smith"'
+     * items = new Map([['"John","Smith"', {"lastName": "Smith", "firstName": "John", "age": 42}]])
+     * ```
+     */
+    forItem(item: PartialItemType<Fields, PrimaryKey>): string;
+}
+/**
+ * Root type for something that looks like the field list we use to sync with the data-sync service.
+ * Used just to make writing other internal types easier.
+ */
+declare type FieldsStructure = {
+    [Name in string]: {
+        type: Readonly<FieldTypeDefinition>;
+        mapping?: undefined | readonly SemanticKind[];
+    };
+};
+/**
+ * The type of a item in the FieldsStructure, that is if the FieldsStructure represents
+ *
+ * ```
+ * [{Name: "id", Type: ScalarFieldTypeEnum.STRING}]
+ * ```
+ *
+ * then ItemType for that would be:
+ *
+ * ```
+ * {'id': string}
+ * ```
+ */
+export declare type ItemType<Fields extends FieldsStructure> = {
+    [Field in keyof Fields]: TsTypeOf<Fields[Field]['type']>;
+};
+/**
+ * Just like ItemType<Foo>, but the fields not part of the primary key can be undefined.
+ */
+export declare type PartialItemType<Fields extends FieldsStructure, PrimaryKey extends keyof Fields> = Pick<ItemType<Fields>, PrimaryKey> & Partial<Omit<ItemType<Fields>, PrimaryKey>>;
+export {};

package/sdk/core/data/fieldspecification.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormattedPrimaryKey = exports.declareSchema = void 0;
+const object_1 = require("../object");
+function isArrayAndAssertReadonly(val) {
+    return Array.isArray(val);
+}
+/**
+ * Specifies all the fields that this itegration will be sending to the data-sync service.
+ * Give you well typed methods to convert from `YourType[]` to `{[PrimaryKey:string]: YourType}`
+ * which is what most of the data sync service calls expect.
+ *
+ * There is fromItems which does the above will full type information, and fromItems sparse
+ * which allows all the fields not part of the primaryKey to be undefined. The former should
+ * be used with initial imports, and the latter can be used for updates.
+ */
+function declareSchema({ primaryKey, fields }) {
+    const primaryKeyObj = new FormattedPrimaryKey(...primaryKey);
+    return {
+        example: fields,
+        array: (0, object_1.entries)(fields).map(([name, { type, constraints, mapping }]) => {
+            return {
+                'name': name,
+                'type': isArrayAndAssertReadonly(type) ? type.slice() : type,
+                'constraints': constraints,
+                'mapping': mapping,
+            };
+        }),
+        primaryKey: primaryKeyObj,
+        fromItemsSparse: (items) => {
+            return new Map(items.map((item) => [primaryKeyObj.forItem(item), item]));
+        },
+        fromItems: (items) => {
+            return new Map(items.map((item) => [primaryKeyObj.forItem(item), item]));
+        },
+    };
+}
+exports.declareSchema = declareSchema;
+/**
+ * Generates a mapper that, given a primary key definition is able to produce the primary key for that item.
+ **/
+class FormattedPrimaryKey {
+    constructor(...elements) {
+        this.elements = [...elements].sort();
+    }
+    /**
+     * Generate the serialized form of the item's primary key.
+     *
+     * For single value primary keys, the encoded values are just the json representation of the primary
+     * key. For example, if the primary key is ['id'] the following table shows encodings:
+     *
+     * | type    | value     | encoded                            |
+     * |---------|-----------|------------------------------------|
+     * | number  | `15`      | `new Map([["15", ...], ...])`      |
+     * | boolean | `false`   | `new Map([["false", ...], ...])`   |
+     * | string  | `"hello"` | `new Map([['"hello"', ...], ...])` |
+     *
+     * Take note of the extra quotes in the string case.
+     *
+     * For primary keys with multiple values, first sort the array of primary keys then join the json encoded values
+     * from of the keys with commas. For example:
+     *
+     * ```
+     * primary key = ["lastName", "firstName"]
+     * sorted key = ["firstName", "lastName"]
+     * row = {"lastName": "Smith", "firstName": "John", "age": 42}
+     * row key = '"John","Smith"'
+     * items = new Map([['"John","Smith"', {"lastName": "Smith", "firstName": "John", "age": 42}]])
+     * ```
+     */
+    forItem(item) {
+        let pk = JSON.stringify(this.elements.map((field) => item[field]));
+        pk = pk.substring(1, pk.length - 1);
+        return pk;
+    }
+}
+exports.FormattedPrimaryKey = FormattedPrimaryKey;

package/sdk/core/object.d.ts

@@ -1,6 +1,10 @@
 export declare function objectEvery<T, O extends {
     [key: string]: any;
 }>(obj: O, f: (this: T | undefined, _0: O[typeof _1], _1: string & keyof O, _2: O) => any, opt_this?: T): boolean;
+export declare function flatten<T>(a: T[][]): T[];
 export declare function entries<T>(obj: {
     [key: string]: T;
 }): [string, T][];
+export declare function fromEntries<K extends PropertyKey, T>(entries: Iterable<readonly [K, T]>): {
+    [key in K]: T;
+};

package/sdk/core/object.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.entries = exports.objectEvery = void 0;
+exports.fromEntries = exports.entries = exports.flatten = exports.objectEvery = void 0;
 function objectEvery(obj, f, opt_this) {
     for (const key in obj) {
         if (!f.call(opt_this, obj[key], key, obj)) {
@@ -10,8 +10,25 @@ function objectEvery(obj, f, opt_this) {
     return true;
 }
 exports.objectEvery = objectEvery;
+function flatten(a) {
+    const result = [];
+    for (const item of a) {
+        result.push(...item);
+    }
+    return result;
+}
+exports.flatten = flatten;
 // TODO: Placeholder until we adopt ES8 and can use Object.entries(obj)
 function entries(obj) {
     return Object.keys(obj).map((key) => [key, obj[key]]);
 }
 exports.entries = entries;
+// TODO: Placeholder until we adopt ES8 and can use Object.fromEntries(obj)
+function fromEntries(entries) {
+    const result = {};
+    for (const [key, value] of entries) {
+        result[key] = value;
+    }
+    return result;
+}
+exports.fromEntries = fromEntries;

package/sdk/data/dataupdatefiltertype.d.ts

@@ -0,0 +1,9 @@
+/** Allows Lucid documents to determine what updates they will receive when changes happen in the data source */
+export declare enum DataUpdateFilterType {
+    /** All updates relevant to the data source will be sent to the document, new items created in the data source will be added to the document */
+    'AllUpdates' = "AllUpdates",
+    /** All updates relevant to collections already present on the document will be sent to that document, new items added to those collections in the data source will be added to the document */
+    'CurrentCollectionUpdates' = "CurrentCollectionUpdates",
+    /** All updates to items already present on the document will be sent to the document. New items created in the data source will not be created on the document. */
+    'CurrentItemUpdates' = "CurrentItemUpdates"
+}

package/sdk/data/dataupdatefiltertype.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataUpdateFilterType = void 0;
+/** Allows Lucid documents to determine what updates they will receive when changes happen in the data source */
+var DataUpdateFilterType;
+(function (DataUpdateFilterType) {
+    /** All updates relevant to the data source will be sent to the document, new items created in the data source will be added to the document */
+    DataUpdateFilterType["AllUpdates"] = "AllUpdates";
+    /** All updates relevant to collections already present on the document will be sent to that document, new items added to those collections in the data source will be added to the document */
+    DataUpdateFilterType["CurrentCollectionUpdates"] = "CurrentCollectionUpdates";
+    /** All updates to items already present on the document will be sent to the document. New items created in the data source will not be created on the document. */
+    DataUpdateFilterType["CurrentItemUpdates"] = "CurrentItemUpdates";
+})(DataUpdateFilterType = exports.DataUpdateFilterType || (exports.DataUpdateFilterType = {}));

package/sdk/dataconnector/actions/action.d.ts

@@ -0,0 +1,153 @@
+import { DataUpdateFilterType } from '../../data/dataupdatefiltertype';
+import { DataSourceClient } from '../datasourceclient';
+import { PatchChange, PatchChangeCollection } from './patchresponsebody';
+export declare type CollectionId = string;
+export declare type ItemPrimaryKey = string;
+/**
+ * This holds all the contextual information about a give data action.
+ */
+export declare class DataConnectorActionContext {
+    /** The package ID of the extension that triggered this action */
+    readonly packageId: string;
+    /** The version of the extension that triggered this action */
+    packageVersion: string;
+    /** The authorized OAuth2 credential that Lucid has for the 3rd party this extension works with */
+    userCredential: string;
+    /** The data connector name from manifest.json that triggered this action */
+    dataConnectorName: string;
+    /** The installation id of the extension/user that triggered this action */
+    installationId: string | undefined;
+    /** Set of items this document is tracking as a `Record<CollectionId, ItemPrimaryKey[]>` */
+    documentCollections: {
+        [collectionId: CollectionId]: ItemPrimaryKey[];
+    };
+    /** Update filter type for this document */
+    updateFilterType: DataUpdateFilterType;
+    constructor(
+    /** The package ID of the extension that triggered this action */
+    packageId: string, 
+    /** The version of the extension that triggered this action */
+    packageVersion: string, 
+    /** The authorized OAuth2 credential that Lucid has for the 3rd party this extension works with */
+    userCredential: string, 
+    /** The data connector name from manifest.json that triggered this action */
+    dataConnectorName: string, 
+    /** The installation id of the extension/user that triggered this action */
+    installationId: string | undefined, 
+    /** Set of items this document is tracking as a `Record<CollectionId, ItemPrimaryKey[]>` */
+    documentCollections: {
+        [collectionId: CollectionId]: ItemPrimaryKey[];
+    }, 
+    /** Update filter type for this document */
+    updateFilterType: DataUpdateFilterType);
+}
+/** Base class for actions to be performed by data connectors */
+export declare class DataConnectorAction {
+    name: string;
+    context: DataConnectorActionContext;
+    constructor(name: string, context: DataConnectorActionContext);
+}
+/**
+ * A generic "asynchronous" action to be performed by the data connector. This is an action that reports back to Lucid
+ * by calling back in the DataSourceClient rather than returning a meaningful value.
+ **/
+export declare class DataConnectorAsynchronousAction extends DataConnectorAction {
+    client: DataSourceClient;
+    data: unknown;
+    constructor(name: string, context: DataConnectorActionContext, client: DataSourceClient, data: unknown);
+}
+/**
+ * A generic "synchronous" action to be performed by the data connector.
+ **/
+export declare class DataConnectorSynchronousAction extends DataConnectorAction {
+    data: unknown;
+    constructor(name: string, context: DataConnectorActionContext, data: unknown);
+}
+export declare type PatchItems = {
+    [primaryKey: ItemPrimaryKey]: {
+        [fieldName: string]: unknown;
+    };
+};
+/** A patch to be applied against the 3rd party datasource with changes coming from Lucid */
+export declare class Patch {
+    /** The id of the patch */
+    id: string;
+    /** Mapping of item primary keys to new items introduced by Lucid */
+    itemsAdded: PatchItems;
+    /** Mapping of item primary keys to sparse changesets of pre-existing items changed by Lucid */
+    itemsChanged: PatchItems;
+    /** List of item primary keys deleted by Lucid */
+    itemsDeleted: string[];
+    /** The syncSourceId of the changed data source */
+    syncSourceId: string;
+    /** The syncCollectionId of the changed collection */
+    syncCollectionId: CollectionId;
+    constructor(
+    /** The id of the patch */
+    id: string, 
+    /** Mapping of item primary keys to new items introduced by Lucid */
+    itemsAdded: PatchItems, 
+    /** Mapping of item primary keys to sparse changesets of pre-existing items changed by Lucid */
+    itemsChanged: PatchItems, 
+    /** List of item primary keys deleted by Lucid */
+    itemsDeleted: string[], 
+    /** The syncSourceId of the changed data source */
+    syncSourceId: string, 
+    /** The syncCollectionId of the changed collection */
+    syncCollectionId: CollectionId);
+    getChange(collections?: PatchChangeCollection[]): PatchChange;
+}
+/**
+ * A patch action is a kind of synchronous style action. It occurs when data is changed in the Lucid editor. All the
+ * changes are collected in the patches field.
+ **/
+export declare class DataConnectorPatchAction extends DataConnectorAction {
+    patches: Patch[];
+    constructor(context: DataConnectorActionContext, /** changes applied by Lucid */ patches: Patch[]);
+}
+/**
+ * A description of an existing webhook that Lucid is keeping track of.
+ **/
+export declare class Webhook {
+    /** Set of items this webhook is tracking as a `Record<CollectionId, ItemPrimaryKey[]>` */
+    documentCollections: {
+        [collectionId: CollectionId]: ItemPrimaryKey[];
+    };
+    /** Arbitrary extra data to allow the data connector to better identitify the webhook. */
+    webhookData: unknown;
+    constructor(
+    /** Set of items this webhook is tracking as a `Record<CollectionId, ItemPrimaryKey[]>` */
+    documentCollections: {
+        [collectionId: CollectionId]: ItemPrimaryKey[];
+    }, 
+    /** Arbitrary extra data to allow the data connector to better identitify the webhook. */
+    webhookData: unknown);
+}
+/**
+ * A "synchronous" style action indicating that Lucid would like to setup a webhook in the third party.
+ */
+export declare class DataConnectorManageWebhookAction extends DataConnectorAction {
+    /**
+     * Token to be added to the newly created webhook so that when it fires it will have permissions to make changes
+     * to Lucid documents.
+     */
+    webhookToken: string;
+    /**
+     * A list of existing webhooks so you can be more granular about what you track. You may also find it useful to
+     * delete some of the existing webhooks. The response back to Lucid should include all existing webhooks (newly
+     * created or any of these that were not deleted).
+     **/
+    webhooks: Webhook[];
+    constructor(context: DataConnectorActionContext, 
+    /**
+     * Token to be added to the newly created webhook so that when it fires it will have permissions to make changes
+     * to Lucid documents.
+     */
+    webhookToken: string, 
+    /**
+     * A list of existing webhooks so you can be more granular about what you track. You may also find it useful to
+     * delete some of the existing webhooks. The response back to Lucid should include all existing webhooks (newly
+     * created or any of these that were not deleted).
+     **/
+    webhooks: Webhook[]);
+}

package/sdk/dataconnector/actions/action.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataConnectorManageWebhookAction = exports.Webhook = exports.DataConnectorPatchAction = exports.Patch = exports.DataConnectorSynchronousAction = exports.DataConnectorAsynchronousAction = exports.DataConnectorAction = exports.DataConnectorActionContext = void 0;
+const patchresponsebody_1 = require("./patchresponsebody");
+/**
+ * This holds all the contextual information about a give data action.
+ */
+class DataConnectorActionContext {
+    constructor(
+    /** The package ID of the extension that triggered this action */
+    packageId, 
+    /** The version of the extension that triggered this action */
+    packageVersion, 
+    /** The authorized OAuth2 credential that Lucid has for the 3rd party this extension works with */
+    userCredential, 
+    /** The data connector name from manifest.json that triggered this action */
+    dataConnectorName, 
+    /** The installation id of the extension/user that triggered this action */
+    installationId, 
+    /** Set of items this document is tracking as a `Record<CollectionId, ItemPrimaryKey[]>` */
+    documentCollections, 
+    /** Update filter type for this document */
+    updateFilterType) {
+        this.packageId = packageId;
+        this.packageVersion = packageVersion;
+        this.userCredential = userCredential;
+        this.dataConnectorName = dataConnectorName;
+        this.installationId = installationId;
+        this.documentCollections = documentCollections;
+        this.updateFilterType = updateFilterType;
+    }
+}
+exports.DataConnectorActionContext = DataConnectorActionContext;
+/** Base class for actions to be performed by data connectors */
+class DataConnectorAction {
+    constructor(name, context) {
+        this.name = name;
+        this.context = context;
+    }
+}
+exports.DataConnectorAction = DataConnectorAction;
+/**
+ * A generic "asynchronous" action to be performed by the data connector. This is an action that reports back to Lucid
+ * by calling back in the DataSourceClient rather than returning a meaningful value.
+ **/
+class DataConnectorAsynchronousAction extends DataConnectorAction {
+    constructor(name, context, client, data) {
+        super(name, context);
+        this.client = client;
+        this.data = data;
+    }
+}
+exports.DataConnectorAsynchronousAction = DataConnectorAsynchronousAction;
+/**
+ * A generic "synchronous" action to be performed by the data connector.
+ **/
+class DataConnectorSynchronousAction extends DataConnectorAction {
+    constructor(name, context, data) {
+        super(name, context);
+        this.data = data;
+    }
+}
+exports.DataConnectorSynchronousAction = DataConnectorSynchronousAction;
+/** A patch to be applied against the 3rd party datasource with changes coming from Lucid */
+class Patch {
+    constructor(
+    /** The id of the patch */
+    id, 
+    /** Mapping of item primary keys to new items introduced by Lucid */
+    itemsAdded, 
+    /** Mapping of item primary keys to sparse changesets of pre-existing items changed by Lucid */
+    itemsChanged, 
+    /** List of item primary keys deleted by Lucid */
+    itemsDeleted, 
+    /** The syncSourceId of the changed data source */
+    syncSourceId, 
+    /** The syncCollectionId of the changed collection */
+    syncCollectionId) {
+        this.id = id;
+        this.itemsAdded = itemsAdded;
+        this.itemsChanged = itemsChanged;
+        this.itemsDeleted = itemsDeleted;
+        this.syncSourceId = syncSourceId;
+        this.syncCollectionId = syncCollectionId;
+    }
+    getChange(collections = []) {
+        return new patchresponsebody_1.PatchChange(this.id, this.syncSourceId, collections);
+    }
+}
+exports.Patch = Patch;
+/**
+ * A patch action is a kind of synchronous style action. It occurs when data is changed in the Lucid editor. All the
+ * changes are collected in the patches field.
+ **/
+class DataConnectorPatchAction extends DataConnectorAction {
+    constructor(context, /** changes applied by Lucid */ patches) {
+        super('Patch', context);
+        this.patches = patches;
+    }
+}
+exports.DataConnectorPatchAction = DataConnectorPatchAction;
+/**
+ * A description of an existing webhook that Lucid is keeping track of.
+ **/
+class Webhook {
+    constructor(
+    /** Set of items this webhook is tracking as a `Record<CollectionId, ItemPrimaryKey[]>` */
+    documentCollections, 
+    /** Arbitrary extra data to allow the data connector to better identitify the webhook. */
+    webhookData) {
+        this.documentCollections = documentCollections;
+        this.webhookData = webhookData;
+    }
+}
+exports.Webhook = Webhook;
+/**
+ * A "synchronous" style action indicating that Lucid would like to setup a webhook in the third party.
+ */
+class DataConnectorManageWebhookAction extends DataConnectorAction {
+    constructor(context, 
+    /**
+     * Token to be added to the newly created webhook so that when it fires it will have permissions to make changes
+     * to Lucid documents.
+     */
+    webhookToken, 
+    /**
+     * A list of existing webhooks so you can be more granular about what you track. You may also find it useful to
+     * delete some of the existing webhooks. The response back to Lucid should include all existing webhooks (newly
+     * created or any of these that were not deleted).
+     **/
+    webhooks) {
+        super('ManageWebhook', context);
+        this.webhookToken = webhookToken;
+        this.webhooks = webhooks;
+    }
+}
+exports.DataConnectorManageWebhookAction = DataConnectorManageWebhookAction;

package/sdk/dataconnector/actions/managewebhookresponsebody.d.ts

@@ -0,0 +1,8 @@
+import { Webhook } from './action';
+/** Convert the ManageWebhookResponse to Lucid's wire format */
+export declare function serializeManageWebhookResponse(webhookResponse: Webhook): SerializedManageWebhookResponseBody;
+/** Wire format for ManageWebhookResponses */
+export declare type SerializedManageWebhookResponseBody = {
+    'documentCollections': Record<string, string[]>;
+    'webhookData': unknown;
+};

package/sdk/dataconnector/actions/managewebhookresponsebody.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeManageWebhookResponse = void 0;
+/** Convert the ManageWebhookResponse to Lucid's wire format */
+function serializeManageWebhookResponse(webhookResponse) {
+    return {
+        'documentCollections': webhookResponse.documentCollections,
+        'webhookData': webhookResponse.webhookData,
+    };
+}
+exports.serializeManageWebhookResponse = serializeManageWebhookResponse;