lucid-extension-sdk 0.0.130 → 0.0.132

package/package.json

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

package/sdk/core/cardintegration/cardfielddisplaysettings.d.ts

@@ -54,6 +54,10 @@ export declare enum OnClickHandlerKeys {
     OpenBrowserWindow = "OpenBrowserWindow"
 }
 export declare const isOnClickHandlerKey: (x: unknown) => x is OnClickHandlerKeys;
+export declare type ImageBadgeSettings = {
+    height: number;
+    width: number;
+};
 export interface StencilConfig {
     /**
      * How should we generate the stencil/data graphic from the specified field value?
@@ -69,6 +73,21 @@ export interface StencilConfig {
      * by starting the string with "=", e.g. "=darken("#ffffff", 0.5)"
      */
     backgroundColor?: string;
+    /**
+     * For displayType values that support it, you may provide an override for the
+     * foreground color for this data. If this is not provided, the foreground color
+     * will default to grey.
+     *
+     * This may be provided as a literal color hex, e.g. "#00ff00ff" or as a formula
+     * by starting the string with "=", e.g. "=darken("#ffffff", 0.5)"
+     */
+    foregroundColor?: string;
+    /**
+     * For displayType values that support it, you may provide a height and a width
+     * for the image size. Images are 24px by 24px by default.
+     *
+     */
+    imageBadgeSettings?: ImageBadgeSettings;
     /**
      * If specified, the result of this formula (executed in the context of the data item
      * associated with this card) will be used instead of the raw field value when
@@ -114,6 +133,7 @@ export declare type SerializedLucidCardFieldDisplaySettings = {
     'StencilConfig'?: {
         /** Since renamed to displayType, but we can't change the serialized name */
         'getterKey': FieldDisplayType;
+        'fg'?: string;
         'bg'?: string;
         'f'?: string;
         't'?: string;
@@ -121,6 +141,7 @@ export declare type SerializedLucidCardFieldDisplaySettings = {
         'h'?: HorizontalBadgePos;
         'v'?: VerticalBadgePos;
         'onClickHandlerKey'?: OnClickHandlerKeys;
+        'imageBadgeSettings'?: ImageBadgeSettings;
     };
 };
 /** @ignore */

package/sdk/core/cardintegration/cardfielddisplaysettings.js

@@ -67,10 +67,12 @@ function serializeLucidCardFieldDisplaySettings(settings) {
             'f': settings.stencilConfig.valueFormula,
             't': settings.stencilConfig.tooltipFormula,
             'l': settings.stencilConfig.linkFormula,
+            'fg': settings.stencilConfig.foregroundColor,
             'bg': settings.stencilConfig.backgroundColor,
             'h': settings.stencilConfig.horizontalPosition,
             'v': settings.stencilConfig.verticalPosition,
             'onClickHandlerKey': settings.stencilConfig.onClickHandlerKey,
+            'imageBadgeSettings': settings.stencilConfig.imageBadgeSettings,
         },
     };
 }
@@ -83,10 +85,12 @@ function deserializeLucidCardFieldDisplaySettings(settings) {
             valueFormula: settings['StencilConfig']['f'],
             tooltipFormula: settings['StencilConfig']['t'],
             linkFormula: settings['StencilConfig']['l'],
+            foregroundColor: settings['StencilConfig']['fg'],
             backgroundColor: settings['StencilConfig']['bg'],
             horizontalPosition: settings['StencilConfig']['h'],
             verticalPosition: settings['StencilConfig']['v'],
             onClickHandlerKey: settings['StencilConfig']['onClickHandlerKey'],
+            imageBadgeSettings: settings['StencilConfig']['imageBadgeSettings'],
         },
     };
 }

package/sdk/dataconnector/dataconnector.d.ts

@@ -30,6 +30,11 @@ export declare class DataConnectorRequestError extends Error {
     response: string;
     constructor(status: number, message: string, response: string);
 }
+/** Thrown by any APIs the client didn't recognize when parsing */
+export declare class DataConnectorResponseError extends Error {
+    response: string;
+    constructor(message: string, response: string);
+}
 declare type ActionTypeForName<Name extends string, Asynchronous = boolean> = Name extends `${DataConnectorActionKeys.Patch}` ? ActionRequest<DataConnectorPatchAction, PatchChange[]> : Name extends `${DataConnectorActionKeys.UnbatchedPatch}` ? ActionRequest<DataConnectorPatchAction, PatchChange[]> : Name extends `${DataConnectorActionKeys.ManageWebhook}` ? ActionRequest<DataConnectorManageWebhookAction, Webhook> : ActionRequest<Asynchronous extends true ? DataConnectorAsynchronousAction : DataConnectorAction>;
 /** Factory class to define a bunch of action handlers. */
 export declare class DataConnector {

package/sdk/dataconnector/dataconnector.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DataConnector = exports.DataConnectorRequestError = exports.DataConnectorRunError = void 0;
+exports.DataConnector = exports.DataConnectorResponseError = exports.DataConnectorRequestError = exports.DataConnectorRunError = void 0;
 const checks_1 = require("../core/checks");
 const action_1 = require("./actions/action");
 const dataconnectoractionkeys_1 = require("./actions/dataconnectoractionkeys");
@@ -29,6 +29,14 @@ class DataConnectorRequestError extends Error {
     }
 }
 exports.DataConnectorRequestError = DataConnectorRequestError;
+/** Thrown by any APIs the client didn't recognize when parsing */
+class DataConnectorResponseError extends Error {
+    constructor(message, response) {
+        super(message);
+        this.response = response;
+    }
+}
+exports.DataConnectorResponseError = DataConnectorResponseError;
 /** Factory class to define a bunch of action handlers. */
 class DataConnector {
     constructor(client) {

package/sdk/dataconnector/dataconnectorclient.js

@@ -19,7 +19,7 @@ class DataConnectorClient {
     }
     /** Get a client for DataSource related requests to Lucid */
     getDataSourceClient(updateToken) {
-        return new datasourceclient_1.DataSourceClient(`${this.urls.api}data/dataSource/update`, updateToken, this.fetchMethod);
+        return new datasourceclient_1.DataSourceClient(this.urls, updateToken, this.fetchMethod);
     }
     /** Get a validator to prove a given request came from Lucid */
     async getSignatureValidator() {

package/sdk/dataconnector/datasourceclient.d.ts

@@ -1,74 +1,26 @@
-import { SerializedFieldTypeDefinition } from '../core/data/fieldtypedefinition/fieldtypedefinition';
-import { SemanticKind } from '../core/data/fieldtypedefinition/semantickind';
-import type { FieldConstraintType } from '../core/data/serializedfield/serializedfielddefinition';
-import { SerializedFields } from '../core/data/serializedfield/serializedfields';
-import { JsonSerializable } from '../core/jsonserializable';
-import type { DataUpdateFilterType } from '../data/dataupdatefiltertype';
-import { FieldDefinition, SchemaDefinition } from '../data/schemadefinition';
-/**
- * Container for an update to a data source
- */
-export declare type DataSourceRequest = {
-    /** The current update filter type associated with this request */
-    updateFilterType?: DataUpdateFilterType;
-    /** The name of the data source to be added or modified */
-    dataSourceName: string;
-    /** Collections to add or update to the data source */
-    collections: Record<string, CollectionPatch>;
-};
-declare type SerializedFieldConstraintForApi = {
-    'type': FieldConstraintType;
-    'details'?: JsonSerializable;
-};
-declare type SerializedFieldDefinitionForApi = {
-    'name': string;
-    'type': SerializedFieldTypeDefinition;
-    'constraints': SerializedFieldConstraintForApi[];
-    'syncSchema'?: string;
-    'mapping'?: readonly SemanticKind[];
-};
-/**
- * A patch to a collection or the definition of a new collection to be added. If adding a new collection, a schema must
- * be provided. If modifying an existing collection, a schema may be omitted.
- **/
-export interface CollectionPatch {
-    /**
-     * If changing an existing schema only the following changes are allowed:
-     *
-     * 1. Adding a nullable field
-     * 2. Promoting a type of a field to a union of types (`string` -> `string | number`)
-     * 3. Adding a new variant to a union type (`string | number` -> `string | number | boolean`)
-     *
-     * * Removing a field is not allowed (just add `| null` and don't provide the field in patches anymore).
-     * * Changing a type in a way that any existing legal value is no longer valid for that field is not allowed.
-     */
-    schema?: SchemaDefinition;
-    /** The patch to apply to the collection */
-    patch: {
-        /**
-         * Items to be added or changed in the collection. Mapping from item serialized primary key to
-         * the sparse patch of the item. See FormattedPrimaryKey.forItem.
-         **/
-        items: Map<string, SerializedFields>;
-        /** Items to remove from the collection, based on the same primary key algorithm. */
-        itemsDeleted?: string[];
-    };
-}
-/** @ignore */
-export declare function serializeFieldDefinitionForApi(field: FieldDefinition): SerializedFieldDefinitionForApi;
+import { MetadataPatch, MetadataPatchResponse, MetadataRecord } from './datasourcemetadatatypes';
+import { DataSourceRequest } from './datasourceupdatetypes';
 /**
  * Authenticated client for DataSource related requests to Lucid.
  */
 export declare class DataSourceClient {
-    private url;
+    private urls;
     private updateToken;
     private fetchMethod;
-    constructor(url: string, updateToken: string, fetchMethod?: import("./defaultfetchfunction").GlobalFetchType);
+    private readonly metadataUrl;
+    constructor(urls: {
+        main: string;
+        api: string;
+    }, updateToken: string, fetchMethod?: import("./defaultfetchfunction").GlobalFetchType);
     private formatBody;
     /** Create or update a datasource. If you create a new collection it must be fully specified in terms of schema and
      * and items. If it's just an update then the schema can be omitted (if unchanged) and items that already exist can
      * be partial.*/
     update(request: DataSourceRequest): Promise<void>;
+    /** @ignore until metadata endpoints are made part of the public API */
+    getMetadata(keys: string[]): Promise<MetadataRecord[]>;
+    /** @ignore until metadata endpoints are made part of the public API */
+    patchMetadata(patches: MetadataPatch[]): Promise<MetadataPatchResponse>;
 }
 /**
  * A version of the DataSourceClient that you can use for any automated tests of your data connector.
@@ -77,8 +29,15 @@ export declare class DataSourceClient {
 export declare class MockDataSourceClient extends DataSourceClient {
     /** Assign this to your mocked update function */
     gotUpdate: (request: DataSourceRequest) => void;
+    /** Assign this to your mocked update function */
+    gotMetadata: (keys: string[]) => MetadataRecord[];
+    /** Assign this to your mocked update function */
+    patchedMetadata: (patches: MetadataPatch[]) => MetadataPatchResponse;
     constructor();
     /** @ignore */
     update(request: DataSourceRequest): Promise<void>;
+    /** @ignore */
+    getMetadata(keys: string[]): Promise<MetadataRecord[]>;
+    /** @ignore */
+    patchMetadata(patches: MetadataPatch[]): Promise<MetadataPatchResponse>;
 }
-export {};

package/sdk/dataconnector/datasourceclient.js

@@ -1,56 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MockDataSourceClient = exports.DataSourceClient = exports.serializeFieldDefinitionForApi = void 0;
-const fieldtypedefinition_1 = require("../core/data/fieldtypedefinition/fieldtypedefinition");
-const object_1 = require("../core/object");
+exports.MockDataSourceClient = exports.DataSourceClient = void 0;
+const checks_1 = require("../core/checks");
+const validators_1 = require("../core/validators/validators");
+const dataconnector_1 = require("./dataconnector");
+const datasourcemetadatatypes_1 = require("./datasourcemetadatatypes");
+const datasourceupdatetypes_1 = require("./datasourceupdatetypes");
 const defaultfetchfunction_1 = require("./defaultfetchfunction");
 const throwunsuccessful_1 = require("./throwunsuccessful");
-function serializeFieldConstraintForApi(constraint) {
-    return {
-        'type': constraint.type,
-        'details': constraint.value,
-    };
-}
-/** @ignore */
-function serializeFieldDefinitionForApi(field) {
-    var _a;
-    return {
-        'name': field.name,
-        'type': (0, fieldtypedefinition_1.serializeFieldTypeDefinition)(field.type),
-        'constraints': ((_a = field.constraints) !== null && _a !== void 0 ? _a : []).map((x) => serializeFieldConstraintForApi(x)),
-        'mapping': field.mapping,
-    };
-}
-exports.serializeFieldDefinitionForApi = serializeFieldDefinitionForApi;
-function serializeSchemaForApi(schema) {
-    return {
-        'fields': schema.fields.map((x) => serializeFieldDefinitionForApi(x)),
-        'primaryKey': schema.primaryKey,
-        'fieldLabelOverrides': schema.fieldLabels,
-    };
-}
-function serializeCollectionPatch(patch) {
-    var _a;
-    return {
-        'schema': patch.schema && serializeSchemaForApi(patch.schema),
-        'itemsPatch': {
-            'items': (0, object_1.fromEntries)(patch.patch.items.entries()),
-            'itemsDeleted': (_a = patch.patch.itemsDeleted) !== null && _a !== void 0 ? _a : [],
-        },
-    };
-}
-const assertIsJustRenamed = () => undefined;
-assertIsJustRenamed();
-assertIsJustRenamed();
-assertIsJustRenamed();
 /**
  * Authenticated client for DataSource related requests to Lucid.
  */
 class DataSourceClient {
-    constructor(url, updateToken, fetchMethod = defaultfetchfunction_1.globalFetch) {
-        this.url = url;
+    constructor(urls, updateToken, fetchMethod = defaultfetchfunction_1.globalFetch) {
+        this.urls = urls;
         this.updateToken = updateToken;
         this.fetchMethod = fetchMethod;
+        const dataSyncUrl = urls.dataSync;
+        this.metadataUrl = (0, checks_1.isString)(dataSyncUrl) ? `${dataSyncUrl}dataSource/metadata` : undefined;
     }
     formatBody({ updateFilterType, dataSourceName, collections }) {
         const upstreamConfig = updateFilterType
@@ -62,7 +29,7 @@ class DataSourceClient {
             : {};
         const updateData = {};
         for (const collectionId in collections) {
-            updateData[collectionId] = serializeCollectionPatch(collections[collectionId]);
+            updateData[collectionId] = (0, datasourceupdatetypes_1.serializeCollectionPatch)(collections[collectionId]);
         }
         return {
             'updateData': updateData,
@@ -74,7 +41,7 @@ class DataSourceClient {
      * and items. If it's just an update then the schema can be omitted (if unchanged) and items that already exist can
      * be partial.*/
     async update(request) {
-        const response = await this.fetchMethod(this.url, {
+        const response = await this.fetchMethod(`${this.urls.api}data/dataSource/update`, {
             'method': 'POST',
             'headers': {
                 'Content-Type': 'application/json',
@@ -94,6 +61,74 @@ class DataSourceClient {
         // return await response.text();
         // but lets avoid users trying to interpret the response
     }
+    /** @ignore until metadata endpoints are made part of the public API */
+    async getMetadata(keys) {
+        if (this.metadataUrl == null) {
+            throw new Error('Attempted to access data sync service metadata endpoints in environment where the URL does not exist!');
+        }
+        const encodedKeys = keys.map(encodeURIComponent);
+        const urlWithParams = `${this.metadataUrl}?metadataKeys=${encodedKeys.join('&metadataKeys=')}`;
+        const response = await this.fetchMethod(urlWithParams, {
+            'method': 'GET',
+            'headers': {
+                'Content-Type': 'application/json',
+                'data-update-token': this.updateToken,
+                'Lucid-Api-Version': '1',
+            },
+        });
+        await (0, throwunsuccessful_1.throwUnsuccessful)(response, 'Error getting data source`s metadata');
+        const responseBody = await response.json();
+        if ((0, validators_1.arrayValidator)(datasourcemetadatatypes_1.isSerializedMetadataRecord)(responseBody)) {
+            return responseBody.map((rawResponse) => {
+                return {
+                    key: rawResponse['key'],
+                    value: rawResponse['value'],
+                };
+            });
+        }
+        else {
+            throw new dataconnector_1.DataConnectorResponseError(`Invalid response to query at '${urlWithParams}'! Expected an array of serialized metadata records`, JSON.stringify(responseBody));
+        }
+    }
+    /** @ignore until metadata endpoints are made part of the public API */
+    async patchMetadata(patches) {
+        if (this.metadataUrl == null) {
+            throw new Error('Attempted to access data sync service metadata endpoints in environment where the URL does not exist!');
+        }
+        const serializedPatches = patches.map((patch) => {
+            return {
+                'key': patch.key,
+                'oldValue': patch.oldValue,
+                'newValue': patch.newValue,
+            };
+        });
+        const response = await this.fetchMethod(this.metadataUrl, {
+            'method': 'PATCH',
+            'headers': {
+                'Content-Type': 'application/json',
+                'data-update-token': this.updateToken,
+                'Lucid-Api-Version': '1',
+            },
+            body: JSON.stringify(serializedPatches),
+        });
+        if (response.status === 409) {
+            const responseBody = await response.json();
+            if ((0, validators_1.arrayValidator)(datasourcemetadatatypes_1.isSerializedMetadataRecord)(responseBody)) {
+                return {
+                    status: 'Conflict',
+                    records: responseBody.map((record) => {
+                        return {
+                            key: record['key'],
+                            value: record['value'],
+                        };
+                    }),
+                };
+            }
+            throw new dataconnector_1.DataConnectorResponseError(`Invalid conflict response to query at '${this.metadataUrl}'! Expected an array of serialized metadata records`, JSON.stringify(responseBody));
+        }
+        await (0, throwunsuccessful_1.throwUnsuccessful)(response, 'Error patching data source`s metadata');
+        return { status: 'NoContent' };
+    }
 }
 exports.DataSourceClient = DataSourceClient;
 /**
@@ -102,15 +137,31 @@ exports.DataSourceClient = DataSourceClient;
  **/
 class MockDataSourceClient extends DataSourceClient {
     constructor() {
-        super('', '');
+        super({ main: '', api: '' }, '');
         /** Assign this to your mocked update function */
         this.gotUpdate = (request) => {
             throw new Error(`Didn't mock request: ${JSON.stringify(request)}`);
         };
+        /** Assign this to your mocked update function */
+        this.gotMetadata = (request) => {
+            throw new Error(`Didn't mock request: ${JSON.stringify(request)}`);
+        };
+        /** Assign this to your mocked update function */
+        this.patchedMetadata = (request) => {
+            throw new Error(`Didn't mock request: ${JSON.stringify(request)}`);
+        };
     }
     /** @ignore */
     update(request) {
         return Promise.resolve(this.gotUpdate(request));
     }
+    /** @ignore */
+    getMetadata(keys) {
+        return Promise.resolve(this.gotMetadata(keys));
+    }
+    /** @ignore */
+    patchMetadata(patches) {
+        return Promise.resolve(this.patchedMetadata(patches));
+    }
 }
 exports.MockDataSourceClient = MockDataSourceClient;

package/sdk/dataconnector/datasourcemetadatatypes.d.ts

@@ -0,0 +1,23 @@
+import { isString, isUnknown } from '../core/checks';
+export interface MetadataPatch {
+    key: string;
+    oldValue: unknown;
+    newValue: unknown;
+}
+export interface MetadataRecord {
+    key: string;
+    value: unknown;
+}
+export declare const isSerializedMetadataRecord: (subject: unknown) => subject is import("..").DestructureGuardedTypeObj<{
+    key: typeof isString;
+    value: typeof isUnknown;
+}>;
+interface NoContent {
+    status: 'NoContent';
+}
+interface Conflict {
+    status: 'Conflict';
+    records: MetadataRecord[];
+}
+export declare type MetadataPatchResponse = NoContent | Conflict;
+export {};

package/sdk/dataconnector/datasourcemetadatatypes.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSerializedMetadataRecord = void 0;
+const checks_1 = require("../core/checks");
+const validators_1 = require("../core/validators/validators");
+exports.isSerializedMetadataRecord = (0, validators_1.objectValidator)({
+    'key': checks_1.isString,
+    'value': checks_1.isUnknown,
+});

package/sdk/dataconnector/datasourceupdatetypes.d.ts

@@ -0,0 +1,73 @@
+import { SerializedFieldTypeDefinition } from '../core/data/fieldtypedefinition/fieldtypedefinition';
+import { SemanticKind } from '../core/data/fieldtypedefinition/semantickind';
+import { FieldConstraintType } from '../core/data/serializedfield/serializedfielddefinition';
+import { SerializedFields } from '../core/data/serializedfield/serializedfields';
+import { SerializedLabelOverrides } from '../core/data/serializedfield/serializedschema';
+import { JsonSerializable } from '../core/jsonserializable';
+import { DataUpdateFilterType } from '../data/dataupdatefiltertype';
+import { FieldDefinition, SchemaDefinition } from '../data/schemadefinition';
+/**
+ * Container for an update to a data source
+ */
+export declare type DataSourceRequest = {
+    /** The current update filter type associated with this request */
+    updateFilterType?: DataUpdateFilterType;
+    /** The name of the data source to be added or modified */
+    dataSourceName: string;
+    /** Collections to add or update to the data source */
+    collections: Record<string, CollectionPatch>;
+};
+declare type SerializedFieldConstraintForApi = {
+    'type': FieldConstraintType;
+    'details'?: JsonSerializable;
+};
+declare type SerializedFieldDefinitionForApi = {
+    'name': string;
+    'type': SerializedFieldTypeDefinition;
+    'constraints': SerializedFieldConstraintForApi[];
+    'syncSchema'?: string;
+    'mapping'?: readonly SemanticKind[];
+};
+declare type SerializedSchemaForApi = {
+    'fields': SerializedFieldDefinitionForApi[];
+    'primaryKey': string[];
+    'fieldLabelOverrides'?: SerializedLabelOverrides | undefined;
+};
+export interface SerializedCollectionPatch {
+    'schema'?: SerializedSchemaForApi;
+    'itemsPatch': {
+        'items': Record<string, SerializedFields>;
+        'itemsDeleted': string[];
+    };
+}
+/**
+ * A patch to a collection or the definition of a new collection to be added. If adding a new collection, a schema must
+ * be provided. If modifying an existing collection, a schema may be omitted.
+ **/
+export interface CollectionPatch {
+    /**
+     * If changing an existing schema only the following changes are allowed:
+     *
+     * 1. Adding a nullable field
+     * 2. Promoting a type of a field to a union of types (`string` -> `string | number`)
+     * 3. Adding a new variant to a union type (`string | number` -> `string | number | boolean`)
+     *
+     * * Removing a field is not allowed (just add `| null` and don't provide the field in patches anymore).
+     * * Changing a type in a way that any existing legal value is no longer valid for that field is not allowed.
+     */
+    schema?: SchemaDefinition;
+    /** The patch to apply to the collection */
+    patch: {
+        /**
+         * Items to be added or changed in the collection. Mapping from item serialized primary key to
+         * the sparse patch of the item. See FormattedPrimaryKey.forItem.
+         **/
+        items: Map<string, SerializedFields>;
+        /** Items to remove from the collection, based on the same primary key algorithm. */
+        itemsDeleted?: string[];
+    };
+}
+/** @ignore */
+export declare function serializeFieldDefinitionForApi(field: FieldDefinition): SerializedFieldDefinitionForApi;
+export declare function serializeCollectionPatch(patch: CollectionPatch): SerializedCollectionPatch;
+export {};

package/sdk/dataconnector/datasourceupdatetypes.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeCollectionPatch = exports.serializeFieldDefinitionForApi = void 0;
+const fieldtypedefinition_1 = require("../core/data/fieldtypedefinition/fieldtypedefinition");
+const object_1 = require("../core/object");
+function serializeFieldConstraintForApi(constraint) {
+    return {
+        'type': constraint.type,
+        'details': constraint.value,
+    };
+}
+/** @ignore */
+function serializeFieldDefinitionForApi(field) {
+    var _a;
+    return {
+        'name': field.name,
+        'type': (0, fieldtypedefinition_1.serializeFieldTypeDefinition)(field.type),
+        'constraints': ((_a = field.constraints) !== null && _a !== void 0 ? _a : []).map((x) => serializeFieldConstraintForApi(x)),
+        'mapping': field.mapping,
+    };
+}
+exports.serializeFieldDefinitionForApi = serializeFieldDefinitionForApi;
+function serializeSchemaForApi(schema) {
+    return {
+        'fields': schema.fields.map((x) => serializeFieldDefinitionForApi(x)),
+        'primaryKey': schema.primaryKey,
+        'fieldLabelOverrides': schema.fieldLabels,
+    };
+}
+function serializeCollectionPatch(patch) {
+    var _a;
+    return {
+        'schema': patch.schema && serializeSchemaForApi(patch.schema),
+        'itemsPatch': {
+            'items': (0, object_1.fromEntries)(patch.patch.items.entries()),
+            'itemsDeleted': (_a = patch.patch.itemsDeleted) !== null && _a !== void 0 ? _a : [],
+        },
+    };
+}
+exports.serializeCollectionPatch = serializeCollectionPatch;
+const assertIsJustRenamed = () => undefined;
+assertIsJustRenamed();
+assertIsJustRenamed();
+assertIsJustRenamed();

package/sdk/index.d.ts

@@ -69,6 +69,8 @@ export * from './dataconnector/actions/serializedactions';
 export * from './dataconnector/dataconnector';
 export * from './dataconnector/dataconnectorclient';
 export * from './dataconnector/datasourceclient';
+export * from './dataconnector/datasourcemetadatatypes';
+export * from './dataconnector/datasourceupdatetypes';
 export * from './dataconnector/signaturevalidator';
 export * from './document/blockclasses/blockproxyregistry';
 export * from './document/blockclasses/cardblockproxy';

package/sdk/index.js

@@ -85,6 +85,8 @@ __exportStar(require("./dataconnector/actions/serializedactions"), exports);
 __exportStar(require("./dataconnector/dataconnector"), exports);
 __exportStar(require("./dataconnector/dataconnectorclient"), exports);
 __exportStar(require("./dataconnector/datasourceclient"), exports);
+__exportStar(require("./dataconnector/datasourcemetadatatypes"), exports);
+__exportStar(require("./dataconnector/datasourceupdatetypes"), exports);
 __exportStar(require("./dataconnector/signaturevalidator"), exports);
 __exportStar(require("./document/blockclasses/blockproxyregistry"), exports);
 __exportStar(require("./document/blockclasses/cardblockproxy"), exports);