lucid-extension-sdk 0.0.34 → 0.0.37

package/package.json

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

package/sdk/commandtypes.d.ts

@@ -23,6 +23,7 @@ export declare const enum CommandName {
     AddShapeData = "asd",
     Alert = "a",
     AnimateViewport = "av",
+    AwaitImport = "ai",
     Bootstrap = "b",
     CancelDragBlockToCanvas = "cdc",
     Confirm = "c",
@@ -56,6 +57,7 @@ export declare const enum CommandName {
     HookCreateItems = "hci",
     HookSelection = "hs",
     HookTextEdit = "hte",
+    ImportCards = "ic",
     KillExtension = "k",
     ListBlocks = "lb",
     ListCollectionFields = "lcf",
@@ -74,6 +76,7 @@ export declare const enum CommandName {
     OffsetItems = "oi",
     PatchDataItems = "pdi",
     RegisterPanel = "rp",
+    RegisterUnfurl = "ru",
     ReloadExtension = "r",
     SendOAuthRequest = "oauth",
     SendUIMessage = "suim",
@@ -123,6 +126,10 @@ export declare type CommandArgs = {
         query: AnimateViewportQuery;
         result: AnimateViewportResult;
     };
+    [CommandName.AwaitImport]: {
+        query: AwaitImportQuery;
+        result: AwaitImportResult;
+    };
     [CommandName.Bootstrap]: {
         query: BootstrapQuery;
         result: BootstrapResult;
@@ -259,6 +266,10 @@ export declare type CommandArgs = {
         query: KillExtensionQuery;
         result: KillExtensionResult;
     };
+    [CommandName.ImportCards]: {
+        query: ImportCardsQuery;
+        result: ImportCardsResult;
+    };
     [CommandName.ListBlocks]: {
         query: ListChildrenQuery;
         result: ListChildrenResult;
@@ -327,6 +338,10 @@ export declare type CommandArgs = {
         query: RegisterPanelQuery;
         result: RegisterPanelResult;
     };
+    [CommandName.RegisterUnfurl]: {
+        query: RegisterUnfurlQuery;
+        result: RegisterUnfurlResult;
+    };
     [CommandName.ReloadExtension]: {
         query: ReloadExtensionQuery;
         result: ReloadExtensionResult;
@@ -401,6 +416,15 @@ export declare type AddCardIntegrationQuery = {
     'gf': string;
     /** Show intro if user has not yet authorized this integration */
     'i'?: string;
+    /** If specified, import modal settings */
+    'im'?: {
+        /** Get search fields action */
+        'gsf': string;
+        /** Search action */
+        's': string;
+        /** Import action */
+        'i': string;
+    };
 };
 export declare type AddCardIntegrationResult = undefined;
 export declare type AddLineTextAreaQuery = {
@@ -462,6 +486,20 @@ export declare type AlertQuery = {
 };
 /** True if they click OK, false otherwise */
 export declare type AlertResult = Promise<boolean>;
+export declare type AwaitImportQuery = {
+    /** Data Connector Name */
+    'n': string;
+    /** Sync data source ID Nonce */
+    's'?: string;
+    /** Sync collection ID */
+    'c': string;
+    /** Keys to await */
+    'pk': string[];
+    /** Timeout in milliseconds; reject returned promise if no data appears in time */
+    't': number;
+};
+/** Promise resolving to the collection ID where the data arrived */
+export declare type AwaitImportResult = Promise<string>;
 export declare type BootstrapQuery = {
     /**
      * Named action that accepts the bootstrap data, and which may return a Promise or void. After awaiting\
@@ -708,6 +746,10 @@ export declare type HookTextEditQuery = {
     'n': string;
 };
 export declare type HookTextEditResult = undefined;
+/** Name of the card integration registered by this extension to show the import dialog for */
+export declare type ImportCardsQuery = string;
+/** Resolves when the import dialog is closed */
+export declare type ImportCardsResult = Promise<void>;
 export declare type KillExtensionQuery = void;
 export declare type KillExtensionResult = undefined;
 export declare type ListChildrenQuery = {
@@ -791,6 +833,13 @@ export declare type RegisterPanelQuery = {
     'i': string;
 };
 export declare type RegisterPanelResult = undefined;
+export declare type RegisterUnfurlQuery = {
+    /** Domain to unfurl, e.g. www.google.com */
+    'd': string;
+    /** Action to call to configure the unfurl */
+    'a': string;
+};
+export declare type RegisterUnfurlResult = boolean;
 export declare type ReloadExtensionQuery = void;
 export declare type ReloadExtensionResult = undefined;
 export declare type SendOAuthRequestQuery = SendXHRQuery & {

package/sdk/commandtypes.js

@@ -10,6 +10,7 @@ exports.commandTitles = new Map([
     ["asd" /* AddShapeData */, 'AddShapeData'],
     ["a" /* Alert */, 'Alert'],
     ["av" /* AnimateViewport */, 'AnimateViewport'],
+    ["ai" /* AwaitImport */, 'AwaitImport'],
     ["b" /* Bootstrap */, 'Bootstrap'],
     ["cdc" /* CancelDragBlockToCanvas */, 'CancelDragBlockToCanvas'],
     ["c" /* Confirm */, 'Confirm'],
@@ -41,6 +42,7 @@ exports.commandTitles = new Map([
     ["hci" /* HookCreateItems */, 'HookCreateItems'],
     ["hs" /* HookSelection */, 'HookSelection'],
     ["hte" /* HookTextEdit */, 'HookTextEdit'],
+    ["ic" /* ImportCards */, 'ImportCards'],
     ["k" /* KillExtension */, 'KillExtension'],
     ["lb" /* ListBlocks */, 'ListBlocks'],
     ["lcf" /* ListCollectionFields */, 'ListCollectionFields'],
@@ -59,6 +61,7 @@ exports.commandTitles = new Map([
     ["oi" /* OffsetItems */, 'OffsetItems'],
     ["pdi" /* PatchDataItems */, 'PatchDataItems'],
     ["rp" /* RegisterPanel */, 'RegisterPanel'],
+    ["ru" /* RegisterUnfurl */, 'RegisterUnfurl'],
     ["r" /* ReloadExtension */, 'ReloadExtension'],
     ["oauth" /* SendOAuthRequest */, 'SendOAuthRequest'],
     ["suim" /* SendUIMessage */, 'SendUIMessage'],

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

@@ -0,0 +1,142 @@
+import { CollectionDefinition } from '../../data/collectiondefinition';
+import { CollectionProxy } from '../../data/collectionproxy';
+import { isString } from '../checks';
+import { FieldTypeDefinition, SerializedFieldTypeDefinition } from '../data/fieldtypedefinition/fieldtypedefinition';
+import { isSerializedFieldType, SerializedFieldType } from '../data/serializedfield/serializedfields';
+/**
+ * When this field is displayed on a card shape, how should it be displayed?
+ */
+export declare enum CardFieldDisplayType {
+    Text = 1,
+    TextBadge = 2,
+    ImageBadge = 3
+}
+/** For fields with Option or ApiOption type, the label and value for each available option */
+export interface ExtensionCardFieldOption {
+    label: string;
+    value: SerializedFieldType;
+}
+export interface ExtensionCardFieldDefinition {
+    /** Data identifier */
+    fieldName: string;
+    /** The text to display on the menu item */
+    label: string;
+    /** Additional information we can provide to users */
+    description?: string;
+    /** Override how a field is displayed */
+    displayType?: CardFieldDisplayType;
+    /**
+     * Override what kind of input to allow the user to edit the value.
+     *   e.g. ScalarFieldTypeEnum.STRING for a text input
+     **/
+    inputType?: FieldTypeDefinition;
+    /** If dataType is Option, the list of options available to choose from */
+    options?: ExtensionCardFieldOption[];
+}
+/** @ignore */
+export declare type SerializedCardFieldOption = {
+    'l': string;
+    'v'?: SerializedFieldType;
+};
+/** @ignore */
+export declare function serializeCardFieldOption(option: ExtensionCardFieldOption): SerializedCardFieldOption;
+/** @ignore */
+export declare type SerializedExtensionCardFieldDefinition = {
+    'n': string;
+    't': string;
+    'd'?: string;
+    'diT'?: CardFieldDisplayType;
+    'daT'?: SerializedFieldTypeDefinition;
+    'op'?: SerializedCardFieldOption[];
+};
+/** @ignore */
+export declare function serializeCardFieldDefinition(field: ExtensionCardFieldDefinition): SerializedExtensionCardFieldDefinition;
+/** @ignore */
+export declare function serializeCardFieldArrayDefinition(fields: ExtensionCardFieldDefinition[]): SerializedExtensionCardFieldDefinition[];
+/** @ignore */
+export declare function deserializeFieldOption(option: SerializedCardFieldOption): ExtensionCardFieldOption;
+export declare const isSerializedFieldOption: (subject: unknown) => subject is import("../guards").DestructureGuardedTypeObj<{
+    l: typeof isString;
+    v: typeof isSerializedFieldType;
+}>;
+export declare const isSerializedFieldOptions: (p1: unknown) => p1 is import("../guards").DestructureGuardedTypeObj<{
+    l: typeof isString;
+    v: typeof isSerializedFieldType;
+}>[];
+/** @ignore */
+export declare function deserializeCardFieldDefinition(field: SerializedExtensionCardFieldDefinition): ExtensionCardFieldDefinition;
+/** @ignore */
+export declare function deserializeCardFieldArrayDefinition(fields: SerializedExtensionCardFieldDefinition[]): ExtensionCardFieldDefinition[];
+export interface CardIntegrationConfig {
+    /**
+     * The data fields to be displayed on cards, as data-linked text fields
+     */
+    fieldNames: string[];
+    /**
+     * The field name to use as the displayed ID of the card, if any
+     */
+    idFieldName?: string;
+}
+/** @ignore */
+export declare type SerializedCardIntegrationConfig = {
+    'f': string[];
+    'id'?: string;
+};
+/** @ignore */
+export declare function serializeCardIntegrationConfig(config: CardIntegrationConfig): SerializedCardIntegrationConfig;
+/** @ignore */
+export declare function deserializeCardIntegrationConfig(raw: SerializedCardIntegrationConfig): CardIntegrationConfig;
+export interface CardIntegration {
+    /**
+     * Label used to identify the integration, e.g. "Jira", which will be used in menu items, etc.
+     * Should be unique within any given extension.
+     */
+    label: string;
+    /**
+     * URL for an icon to display in toolbars, etc. Should be at least 24x24.
+     */
+    iconUrl: string;
+    /**
+     * Callback to provide a list of field definitions for the given collection, if that collection
+     * was imported as part of this card integration.
+     *
+     * Any fields on the schema of the collection that you don't provide a ExtensionCardFieldDefinition
+     * for will have a default definition generated based on the type specified in the schema.
+     */
+    getAllFields: (collection: CollectionProxy) => Promise<ExtensionCardFieldDefinition[]>;
+    /**
+     * 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.
+     */
+    showIntro?: () => void;
+    /**
+     * If specified, allow the user to import cards using the standard card-import modal.
+     */
+    importModal?: {
+        /**
+         * Given the values entered by the user so far into search fields, return the list of all search fields
+         * to display in the search form.
+         */
+        getSearchFields: (searchSoFar: Map<string, SerializedFieldType>) => Promise<ExtensionCardFieldDefinition[]>;
+        /**
+         * Given values entered by the user into the search fields so far, return a collection of data to
+         * display in the results table.
+         */
+        search: (fields: Map<string, SerializedFieldType>) => Promise<{
+            data: CollectionDefinition;
+            fields: ExtensionCardFieldDefinition[];
+        }>;
+        /**
+         * The user checked the boxes beside the given list of items in the collection returned from search().
+         * Import them, and return the collection and primary keys in that final collection that were imported.
+         *
+         * The config provided here is only used on the first import from a given source; on subsequent imports,
+         * the existing config will remain unchanged to preserve any customizations by the user.
+         */
+        import: (primaryKeys: string[]) => Promise<{
+            collection: CollectionProxy;
+            primaryKeys: string[];
+            config: CardIntegrationConfig;
+        }>;
+    };
+}

package/sdk/core/{properties → cardintegration}/cardintegration.js

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deserializeCardFieldArrayDefinition = exports.deserializeCardFieldDefinition = exports.deseializeFieldOption = exports.serializeCardFieldArrayDefinition = exports.serializeCardFieldDefinition = exports.serializeCardFieldOption = exports.CardFieldDataType = exports.CardFieldDisplayType = void 0;
+exports.deserializeCardIntegrationConfig = exports.serializeCardIntegrationConfig = exports.deserializeCardFieldArrayDefinition = exports.deserializeCardFieldDefinition = exports.isSerializedFieldOptions = exports.isSerializedFieldOption = exports.deserializeFieldOption = exports.serializeCardFieldArrayDefinition = exports.serializeCardFieldDefinition = exports.serializeCardFieldOption = exports.CardFieldDisplayType = void 0;
+const checks_1 = require("../checks");
+const fieldtypedefinition_1 = require("../data/fieldtypedefinition/fieldtypedefinition");
+const serializedfields_1 = require("../data/serializedfield/serializedfields");
+const validators_1 = require("../validators/validators");
 /**
  * When this field is displayed on a card shape, how should it be displayed?
  */
@@ -10,14 +14,6 @@ var CardFieldDisplayType;
     CardFieldDisplayType[CardFieldDisplayType["TextBadge"] = 2] = "TextBadge";
     CardFieldDisplayType[CardFieldDisplayType["ImageBadge"] = 3] = "ImageBadge";
 })(CardFieldDisplayType = exports.CardFieldDisplayType || (exports.CardFieldDisplayType = {}));
-var CardFieldDataType;
-(function (CardFieldDataType) {
-    CardFieldDataType[CardFieldDataType["Text"] = 1] = "Text";
-    CardFieldDataType[CardFieldDataType["Number"] = 2] = "Number";
-    /** An enumerated list of options, stored as a string */
-    CardFieldDataType[CardFieldDataType["Option"] = 3] = "Option";
-    CardFieldDataType[CardFieldDataType["Checkbox"] = 4] = "Checkbox";
-})(CardFieldDataType = exports.CardFieldDataType || (exports.CardFieldDataType = {}));
 /** @ignore */
 function serializeCardFieldOption(option) {
     return {
@@ -34,7 +30,7 @@ function serializeCardFieldDefinition(field) {
         't': field.label,
         'd': field.description,
         'diT': field.displayType,
-        'daT': field.dataType,
+        'daT': field.inputType === undefined ? undefined : (0, fieldtypedefinition_1.serializeFieldTypeDefinition)(field.inputType),
         'op': (_a = field.options) === null || _a === void 0 ? void 0 : _a.map(serializeCardFieldOption),
     };
 }
@@ -45,13 +41,18 @@ function serializeCardFieldArrayDefinition(fields) {
 }
 exports.serializeCardFieldArrayDefinition = serializeCardFieldArrayDefinition;
 /** @ignore */
-function deseializeFieldOption(option) {
+function deserializeFieldOption(option) {
     return {
         label: option['l'],
         value: option['v'],
     };
 }
-exports.deseializeFieldOption = deseializeFieldOption;
+exports.deserializeFieldOption = deserializeFieldOption;
+exports.isSerializedFieldOption = (0, validators_1.objectValidator)({
+    'l': checks_1.isString,
+    'v': serializedfields_1.isSerializedFieldType,
+});
+exports.isSerializedFieldOptions = (0, validators_1.arrayValidator)(exports.isSerializedFieldOption);
 /** @ignore */
 function deserializeCardFieldDefinition(field) {
     var _a;
@@ -60,8 +61,8 @@ function deserializeCardFieldDefinition(field) {
         label: field['t'],
         description: field['d'],
         displayType: field['diT'],
-        dataType: field['daT'],
-        options: (_a = field['op']) === null || _a === void 0 ? void 0 : _a.map(deseializeFieldOption),
+        inputType: field['daT'] === undefined ? undefined : (0, fieldtypedefinition_1.deserializeFieldTypeDefinition)(field['daT']),
+        options: (_a = field['op']) === null || _a === void 0 ? void 0 : _a.map(deserializeFieldOption),
     };
 }
 exports.deserializeCardFieldDefinition = deserializeCardFieldDefinition;
@@ -70,3 +71,19 @@ function deserializeCardFieldArrayDefinition(fields) {
     return fields.map(deserializeCardFieldDefinition);
 }
 exports.deserializeCardFieldArrayDefinition = deserializeCardFieldArrayDefinition;
+/** @ignore */
+function serializeCardIntegrationConfig(config) {
+    return {
+        'f': config.fieldNames,
+        'id': config.idFieldName,
+    };
+}
+exports.serializeCardIntegrationConfig = serializeCardIntegrationConfig;
+/** @ignore */
+function deserializeCardIntegrationConfig(raw) {
+    return {
+        fieldNames: raw['f'],
+        idFieldName: raw['id'],
+    };
+}
+exports.deserializeCardIntegrationConfig = deserializeCardIntegrationConfig;

package/sdk/core/unfurl/unfurlcallbacks.d.ts

@@ -0,0 +1,22 @@
+import { UnfurlDetails } from './unfurldetails';
+export declare enum UnfurlCallbackType {
+    Unfurl = "u",
+    AfterUnfurl = "a",
+    Refresh = "r"
+}
+/**
+ * The callbacks that handle unfurls and refreshing.
+ * @ignore
+ */
+export interface UnfurlCallbacks {
+    /**
+     * Callback upon initial unfurl.
+     *
+     * This should return with minimal delay to get a partial unfurl shown to the user as quick as possible.
+     * Final configuration of the unfurl should be done in afterUnfurlCallback.
+     * @param url The url to unfurl
+     * @return The details of the unfurl or undefined
+     * @ignore
+     */
+    unfurlCallback: (url: string) => Promise<UnfurlDetails | undefined>;
+}

package/sdk/core/unfurl/unfurlcallbacks.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnfurlCallbackType = void 0;
+var UnfurlCallbackType;
+(function (UnfurlCallbackType) {
+    UnfurlCallbackType["Unfurl"] = "u";
+    UnfurlCallbackType["AfterUnfurl"] = "a";
+    UnfurlCallbackType["Refresh"] = "r";
+})(UnfurlCallbackType = exports.UnfurlCallbackType || (exports.UnfurlCallbackType = {}));

package/sdk/core/unfurl/unfurldetails.d.ts

@@ -0,0 +1,67 @@
+import { isString } from '../checks';
+import { SerializedUnfurlIframe, UnfurlIframe } from './unfurliframe';
+import { SerializedUnfurlThumbnail, UnfurlThumbnail } from './unfurlthumbnail';
+/**
+ * A definition of the details required to show an unfurl block in the editor.
+ */
+export interface UnfurlDetails {
+    /**
+     * The name of the extension attributed to the unfurl. This is a user facing name that is used to attribute the
+     * unfurl to a specific third party.
+     */
+    providerName: string;
+    /**
+     * The favicon of the provider of this unfurl.
+     */
+    providerFaviconUrl: string;
+    /**
+     * The title associated with the link being unfurled. For example, the document or web page title.
+     */
+    unfurlTitle?: string;
+    /**
+     * If the unfurl supports an expandable iframe, this configuration defines its properties.
+     */
+    iframe?: UnfurlIframe;
+    /**
+     * If the unfurl contains one or more images, this configuration defines those properties.
+     */
+    thumbnails?: UnfurlThumbnail[];
+    /**
+     * The url to show if there are no thumbnails.
+     *
+     * This can be useful to show an initial image while using other mechanisms to add all thumbnails after the unfurl is created.
+     */
+    previewImageUrl?: string;
+}
+/** @ignore */
+export interface SerializedUnfurlDetails {
+    'ProviderName': string;
+    'ProviderFaviconUrl': string;
+    'UnfurlTitle'?: string;
+    'Iframe'?: SerializedUnfurlIframe;
+    'Thumbnails'?: SerializedUnfurlThumbnail[];
+    'PreviewImageUrl'?: string;
+}
+/** @ignore */
+export declare const isValidUnfurlDetails: (subject: unknown) => subject is import("../guards").DestructureGuardedTypeObj<{
+    ProviderName: typeof isString;
+    ProviderFaviconUrl: typeof isString;
+    UnfurlTitle: (x: unknown) => x is string | undefined;
+    Iframe: (x: unknown) => x is import("../guards").DestructureGuardedTypeObj<{
+        IframeUrl: typeof isString;
+        Size: (x: unknown) => x is import("./unfurliframe").UnfurlIframeSize.Standard | undefined;
+    }> | undefined;
+    Thumbnails: (x: unknown) => x is import("../guards").DestructureGuardedTypeObj<{
+        url: typeof isString;
+        width: (x: unknown) => x is number | null | undefined;
+        /**
+         * The title associated with the link being unfurled. For example, the document or web page title.
+         */
+        height: (x: unknown) => x is number | null | undefined;
+    }>[] | undefined;
+    PreviewImageUrl: (x: unknown) => x is string | undefined;
+}>;
+/** @ignore */
+export declare function deserializeUnfurlDetails(raw: SerializedUnfurlDetails): UnfurlDetails;
+/** @ignore */
+export declare function serializeUnfurlDetails(concrete: UnfurlDetails): SerializedUnfurlDetails;

package/sdk/core/unfurl/unfurldetails.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeUnfurlDetails = exports.deserializeUnfurlDetails = exports.isValidUnfurlDetails = void 0;
+const checks_1 = require("../checks");
+const validators_1 = require("../validators/validators");
+const unfurliframe_1 = require("./unfurliframe");
+const unfurlthumbnail_1 = require("./unfurlthumbnail");
+/** @ignore */
+exports.isValidUnfurlDetails = (0, validators_1.objectValidator)({
+    'ProviderName': checks_1.isString,
+    'ProviderFaviconUrl': checks_1.isString,
+    'UnfurlTitle': (0, validators_1.option)(checks_1.isString),
+    'Iframe': (0, validators_1.option)(unfurliframe_1.isValidUnfurlIframe),
+    'Thumbnails': (0, validators_1.option)((0, validators_1.arrayValidator)(unfurlthumbnail_1.isValidUnfurlThumbnail)),
+    'PreviewImageUrl': (0, validators_1.option)(checks_1.isString),
+});
+/** @ignore */
+function deserializeUnfurlDetails(raw) {
+    var _a;
+    return {
+        providerName: raw['ProviderName'],
+        providerFaviconUrl: raw['ProviderFaviconUrl'],
+        unfurlTitle: raw['UnfurlTitle'],
+        iframe: raw['Iframe'] && (0, unfurliframe_1.deserializeUnfurlIframe)(raw['Iframe']),
+        thumbnails: (_a = raw['Thumbnails']) === null || _a === void 0 ? void 0 : _a.map((raw) => (0, unfurlthumbnail_1.deserializeUnfurlThumbnail)(raw)),
+        previewImageUrl: raw['PreviewImageUrl'],
+    };
+}
+exports.deserializeUnfurlDetails = deserializeUnfurlDetails;
+/** @ignore */
+function serializeUnfurlDetails(concrete) {
+    var _a;
+    return {
+        'ProviderName': concrete.providerName,
+        'ProviderFaviconUrl': concrete.providerFaviconUrl,
+        'UnfurlTitle': concrete.unfurlTitle,
+        'Iframe': concrete.iframe && (0, unfurliframe_1.serializeUnfurlIframe)(concrete.iframe),
+        'Thumbnails': (_a = concrete.thumbnails) === null || _a === void 0 ? void 0 : _a.map((raw) => (0, unfurlthumbnail_1.serializeUnfurlThumbnail)(raw)),
+        'PreviewImageUrl': concrete.previewImageUrl,
+    };
+}
+exports.serializeUnfurlDetails = serializeUnfurlDetails;

package/sdk/core/unfurl/unfurliframe.d.ts

@@ -0,0 +1,37 @@
+import { isString } from '../checks';
+/**
+ * An enumeration of of the supported unfurl Iframe sizes.
+ */
+export declare enum UnfurlIframeSize {
+    /**
+     * The standard iframe size.
+     */
+    Standard = "standard"
+}
+/**
+ * A definition of the properties needed to expand an iframe for an unfurl
+ */
+export interface UnfurlIframe {
+    /**
+     * The iframe url
+     */
+    iframeUrl: string;
+    /**
+     * The size of the iframe requested
+     */
+    size?: UnfurlIframeSize;
+}
+/** @ignore */
+export interface SerializedUnfurlIframe {
+    'IframeUrl': string;
+    'Size'?: UnfurlIframeSize;
+}
+/** @ignore */
+export declare const isValidUnfurlIframe: (subject: unknown) => subject is import("../guards").DestructureGuardedTypeObj<{
+    IframeUrl: typeof isString;
+    Size: (x: unknown) => x is UnfurlIframeSize.Standard | undefined;
+}>;
+/** @ignore */
+export declare function deserializeUnfurlIframe(raw: SerializedUnfurlIframe): UnfurlIframe;
+/** @ignore */
+export declare function serializeUnfurlIframe(concrete: UnfurlIframe): SerializedUnfurlIframe;

package/sdk/core/unfurl/unfurliframe.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeUnfurlIframe = exports.deserializeUnfurlIframe = exports.isValidUnfurlIframe = exports.UnfurlIframeSize = void 0;
+const checks_1 = require("../checks");
+const validators_1 = require("../validators/validators");
+/**
+ * An enumeration of of the supported unfurl Iframe sizes.
+ */
+var UnfurlIframeSize;
+(function (UnfurlIframeSize) {
+    /**
+     * The standard iframe size.
+     */
+    UnfurlIframeSize["Standard"] = "standard";
+})(UnfurlIframeSize = exports.UnfurlIframeSize || (exports.UnfurlIframeSize = {}));
+/** @ignore */
+exports.isValidUnfurlIframe = (0, validators_1.objectValidator)({
+    'IframeUrl': checks_1.isString,
+    'Size': (0, validators_1.option)((0, validators_1.stringEnumValidator)(UnfurlIframeSize)),
+});
+/** @ignore */
+function deserializeUnfurlIframe(raw) {
+    return {
+        iframeUrl: raw['IframeUrl'],
+        size: raw['Size'],
+    };
+}
+exports.deserializeUnfurlIframe = deserializeUnfurlIframe;
+/** @ignore */
+function serializeUnfurlIframe(concrete) {
+    return {
+        'IframeUrl': concrete.iframeUrl,
+        'Size': concrete.size,
+    };
+}
+exports.serializeUnfurlIframe = serializeUnfurlIframe;

package/sdk/core/unfurl/unfurlthumbnail.d.ts

@@ -0,0 +1,34 @@
+import { isString } from '../checks';
+/**
+ * A definition of a single unfurl thumbnail
+ */
+export interface UnfurlThumbnail {
+    /**
+     * The URL to fetch the image from
+     */
+    url: string;
+    /**
+     * The width of the image. This is not the height it will be displayed at, but rather the width the image actually is.
+     */
+    width?: number;
+    /**
+     * The height of the image. This is not the height it will be displayed at, but rather the height the image actually is.
+     */
+    height?: number;
+}
+/** @ignore */
+export interface SerializedUnfurlThumbnail {
+    'url': string;
+    'width'?: number | null;
+    'height'?: number | null;
+}
+/** @ignore */
+export declare const isValidUnfurlThumbnail: (subject: unknown) => subject is import("../guards").DestructureGuardedTypeObj<{
+    url: typeof isString;
+    width: (x: unknown) => x is number | null | undefined;
+    height: (x: unknown) => x is number | null | undefined;
+}>;
+/** @ignore */
+export declare function deserializeUnfurlThumbnail(raw: SerializedUnfurlThumbnail): UnfurlThumbnail;
+/** @ignore */
+export declare function serializeUnfurlThumbnail(concrete: UnfurlThumbnail): SerializedUnfurlThumbnail;

package/sdk/core/unfurl/unfurlthumbnail.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeUnfurlThumbnail = exports.deserializeUnfurlThumbnail = exports.isValidUnfurlThumbnail = void 0;
+const checks_1 = require("../checks");
+const validators_1 = require("../validators/validators");
+/** @ignore */
+exports.isValidUnfurlThumbnail = (0, validators_1.objectValidator)({
+    'url': checks_1.isString,
+    'width': (0, validators_1.nullableOption)(checks_1.isNumber),
+    'height': (0, validators_1.nullableOption)(checks_1.isNumber),
+});
+/** @ignore */
+function deserializeUnfurlThumbnail(raw) {
+    var _a, _b;
+    return {
+        url: raw['url'],
+        width: (_a = raw['width']) !== null && _a !== void 0 ? _a : undefined,
+        height: (_b = raw['height']) !== null && _b !== void 0 ? _b : undefined,
+    };
+}
+exports.deserializeUnfurlThumbnail = deserializeUnfurlThumbnail;
+/** @ignore */
+function serializeUnfurlThumbnail(concrete) {
+    return {
+        'url': concrete.url,
+        'width': concrete.width,
+        'height': concrete.height,
+    };
+}
+exports.serializeUnfurlThumbnail = serializeUnfurlThumbnail;

package/sdk/data/collectiondefinition.d.ts

@@ -0,0 +1,16 @@
+import { SerializedFields } from '../core/data/serializedfield/serializedfields';
+import { SerializedSchema } from '../core/data/serializedfield/serializedschema';
+import { SchemaDefinition } from './schemadefinition';
+export interface CollectionDefinition {
+    schema: SchemaDefinition;
+    items: Map<string, SerializedFields>;
+}
+/** @ignore */
+export declare function serializeCollectionDefinition(def: CollectionDefinition): SerializedCollectionDefinition;
+/** @ignore */
+export declare function deserializeCollectionDefinition(raw: SerializedCollectionDefinition): CollectionDefinition;
+/** @ignore */
+export interface SerializedCollectionDefinition {
+    'Schema': SerializedSchema;
+    'Items': [string, SerializedFields][];
+}

package/sdk/data/collectiondefinition.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeCollectionDefinition = exports.serializeCollectionDefinition = void 0;
+const schemadefinition_1 = require("./schemadefinition");
+/** @ignore */
+function serializeCollectionDefinition(def) {
+    return {
+        'Schema': (0, schemadefinition_1.serializeSchemaDefinition)(def.schema),
+        'Items': [...def.items.entries()],
+    };
+}
+exports.serializeCollectionDefinition = serializeCollectionDefinition;
+/** @ignore */
+function deserializeCollectionDefinition(raw) {
+    return {
+        schema: (0, schemadefinition_1.parseSchemaDefinition)(raw['Schema']),
+        items: new Map(raw['Items']),
+    };
+}
+exports.deserializeCollectionDefinition = deserializeCollectionDefinition;

package/sdk/data/schemadefinition.d.ts

@@ -17,6 +17,11 @@ export interface SchemaDefinition {
      * Typically this contains only one field name, and that field is usually unique.
      */
     primaryKey: string[];
+    /**
+     * Maps field names to labels to display in the UI when necessary. If any field name
+     * is not present as a key in this label map, the field name itself will be the label.
+     */
+    fieldLabels?: Record<string, string>;
 }
 /** @ignore */
 export declare function serializeSchemaDefinition(def: SchemaDefinition): SerializedSchema;

package/sdk/data/schemadefinition.js

@@ -12,6 +12,7 @@ function serializeSchemaDefinition(def) {
             };
         }),
         'PrimaryKey': def.primaryKey,
+        'FieldLabelOverrides': def.fieldLabels,
     };
 }
 exports.serializeSchemaDefinition = serializeSchemaDefinition;
@@ -25,6 +26,7 @@ function parseSchemaDefinition(def) {
             };
         }),
         primaryKey: def['PrimaryKey'],
+        fieldLabels: def['FieldLabelOverrides'],
     };
 }
 exports.parseSchemaDefinition = parseSchemaDefinition;

package/sdk/document/blockclasses/blockproxyregistry.js

@@ -1,10 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.findProxyClass = void 0;
+const cardblockproxy_1 = require("./cardblockproxy");
 const customblockproxy_1 = require("./customblockproxy");
 const erdblockproxy_1 = require("./erdblockproxy");
 const linkunfurlblockproxy_1 = require("./linkunfurlblockproxy");
-const allProxyClasses = [erdblockproxy_1.ERDBlockProxy, customblockproxy_1.CustomBlockProxy, linkunfurlblockproxy_1.ExperimentalLinkUnfurlBlockProxy];
+const allProxyClasses = [
+    erdblockproxy_1.ERDBlockProxy,
+    customblockproxy_1.CustomBlockProxy,
+    linkunfurlblockproxy_1.ExperimentalLinkUnfurlBlockProxy,
+    cardblockproxy_1.CardBlockProxy,
+];
 function findProxyClass(className) {
     return allProxyClasses.find((proxy) => proxy.classNameRegex.test(className));
 }

package/sdk/document/blockclasses/cardblockproxy.d.ts

@@ -0,0 +1,4 @@
+import { BlockProxy } from '../blockproxy';
+export declare class CardBlockProxy extends BlockProxy {
+    static classNameRegex: RegExp;
+}

package/sdk/document/blockclasses/cardblockproxy.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CardBlockProxy = void 0;
+const blockproxy_1 = require("../blockproxy");
+class CardBlockProxy extends blockproxy_1.BlockProxy {
+}
+exports.CardBlockProxy = CardBlockProxy;
+CardBlockProxy.classNameRegex = /^LucidCardBlock$/;

package/sdk/document/blockclasses/linkunfurlblockproxy.js

@@ -39,7 +39,7 @@ class ExperimentalLinkUnfurlBlockProxy extends blockproxy_1.BlockProxy {
      * @ignore
      */
     setPreviewThumbnailUrl(thumbnailUrl) {
-        throw new Error('Not yet implemented');
+        this.properties.set('LinkUnfurlThumbnailUrl', thumbnailUrl);
     }
     /**
      * Sets additional thumbnails on the block
@@ -47,7 +47,7 @@ class ExperimentalLinkUnfurlBlockProxy extends blockproxy_1.BlockProxy {
      * @ignore
      */
     setThumbnailUrls(thumbnails) {
-        throw new Error('Not yet implemented');
+        this.properties.set('LinkUnfurlThumbnailUrls', thumbnails);
     }
 }
 exports.ExperimentalLinkUnfurlBlockProxy = ExperimentalLinkUnfurlBlockProxy;

package/sdk/document/mapproxy.d.ts

@@ -9,6 +9,7 @@ export declare class MapProxy<KEY, VALUE> {
     /** @ignore */
     [Symbol.iterator](): Iterator<[KEY, VALUE]>;
     values(): Generator<VALUE, void, unknown>;
+    find(filter: (item: VALUE, key: KEY) => boolean): VALUE | undefined;
     keys(): KEY[];
     get size(): number;
     get(key: KEY): VALUE;

package/sdk/document/mapproxy.js

@@ -27,6 +27,14 @@ class MapProxy {
             }
         }
     }
+    find(filter) {
+        for (const [key, value] of this) {
+            if (filter(value, key)) {
+                return value;
+            }
+        }
+        return undefined;
+    }
     keys() {
         return this.getKeys();
     }

package/sdk/document/taskmanagementcardintegration.d.ts

@@ -1,4 +1,4 @@
-import { CardIntegration } from '../core/properties/cardintegration';
+import { CardIntegration } from '../core/cardintegration/cardintegration';
 import { EditorClient } from '../editorclient';
 export declare class TaskManagementCardIntegration {
     private readonly client;
@@ -10,4 +10,5 @@ export declare class TaskManagementCardIntegration {
      * @param card The definition of the new card integration
      */
     addCardIntegration(card: CardIntegration): void;
+    showCardImport(name: string): import("../commandtypes").ImportCardsResult;
 }

package/sdk/document/taskmanagementcardintegration.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TaskManagementCardIntegration = void 0;
-const cardintegration_1 = require("../core/properties/cardintegration");
+const cardintegration_1 = require("../core/cardintegration/cardintegration");
+const collectiondefinition_1 = require("../data/collectiondefinition");
 const collectionproxy_1 = require("../data/collectionproxy");
 class TaskManagementCardIntegration {
     constructor(client) {
@@ -27,12 +28,43 @@ class TaskManagementCardIntegration {
             showIntroActionName = TaskManagementCardIntegration.nextHookName();
             this.client.registerAction(showIntroActionName, card.showIntro);
         }
-        this.client.sendCommand("aci" /* AddCardIntegration */, {
+        const serialized = {
             'n': card.label,
             'u': card.iconUrl,
             'gf': getFieldsActionName,
             'i': showIntroActionName,
-        });
+        };
+        if (card.importModal) {
+            const importModal = card.importModal;
+            serialized['im'] = {
+                'gsf': TaskManagementCardIntegration.nextHookName(),
+                's': TaskManagementCardIntegration.nextHookName(),
+                'i': TaskManagementCardIntegration.nextHookName(),
+            };
+            this.client.registerAction(serialized['im']['gsf'], async ({ 's': searchSoFar }) => {
+                const result = await importModal.getSearchFields(new Map(searchSoFar));
+                return (0, cardintegration_1.serializeCardFieldArrayDefinition)(result);
+            });
+            this.client.registerAction(serialized['im']['s'], async ({ 's': search }) => {
+                const result = await importModal.search(new Map(search));
+                return {
+                    'd': (0, collectiondefinition_1.serializeCollectionDefinition)(result.data),
+                    'f': (0, cardintegration_1.serializeCardFieldArrayDefinition)(result.fields),
+                };
+            });
+            this.client.registerAction(serialized['im']['i'], async ({ 'pks': primaryKeys }) => {
+                const result = await importModal.import(primaryKeys);
+                return {
+                    'c': result.collection.id,
+                    'pks': result.primaryKeys,
+                    'cfg': (0, cardintegration_1.serializeCardIntegrationConfig)(result.config),
+                };
+            });
+        }
+        this.client.sendCommand("aci" /* AddCardIntegration */, serialized);
+    }
+    showCardImport(name) {
+        return this.client.sendCommand("ic" /* ImportCards */, name);
     }
 }
 exports.TaskManagementCardIntegration = TaskManagementCardIntegration;

package/sdk/editorclient.d.ts

@@ -1,5 +1,7 @@
 import { CommandArgs, CommandName, UnionToIntersection } from './commandtypes';
 import { JsonSerializable } from './core/jsonserializable';
+import { UnfurlCallbacks } from './core/unfurl/unfurlcallbacks';
+import { CollectionProxy } from './data/collectionproxy';
 import { BlockDefinition } from './document/blockdefinition';
 import { BlockProxy } from './document/blockproxy';
 import { ElementProxy } from './document/elementproxy';
@@ -86,6 +88,7 @@ export declare class EditorClient {
      * @throws A string with an error from the data sync server
      */
     performDataAction(flowName: string, dataConnectorName: string, syncDataSourceId?: undefined | string, flowData?: unknown, async?: boolean): Promise<DataActionResult>;
+    awaitDataImport(dataConnectorName: string, syncDataSourceId: undefined | string, syncCollectionId: string, primaryKeys: string[], timeout?: number): Promise<CollectionProxy>;
     /**
      * Make a network request
      * @param request Settings for the network request
@@ -116,6 +119,13 @@ export declare class EditorClient {
      * @param callback Function to execute when this action is invoked
      */
     registerFileUploadAction(name: string, callback: (files: FileUploadData[]) => void): void;
+    /**
+     * @ignore
+     * Registers an handler for link unfurling.
+     * @param domain The domain
+     * @param callbacks The callbacks to call when a link matching the domain is pasted.
+     */
+    experimentalRegisterUnfurlHandler(domain: string, callbacks: UnfurlCallbacks): void;
     /**
      * Remove the callback for a given action. If the action is later invoked, nothing will happen.
      * @param name name of the action to unregister

package/sdk/editorclient.js

@@ -4,6 +4,9 @@ exports.EditorClient = void 0;
 const commandtypes_1 = require("./commandtypes");
 const base64_1 = require("./core/base64");
 const checks_1 = require("./core/checks");
+const unfurlcallbacks_1 = require("./core/unfurl/unfurlcallbacks");
+const unfurldetails_1 = require("./core/unfurl/unfurldetails");
+const collectionproxy_1 = require("./data/collectionproxy");
 const blockproxyregistry_1 = require("./document/blockclasses/blockproxyregistry");
 const blockproxy_1 = require("./document/blockproxy");
 const documentproxy_1 = require("./document/documentproxy");
@@ -11,6 +14,7 @@ const elementproxy_1 = require("./document/elementproxy");
 const groupproxy_1 = require("./document/groupproxy");
 const lineproxy_1 = require("./document/lineproxy");
 const pageproxy_1 = require("./document/pageproxy");
+const registerunfurlmessage_1 = require("./message/registerunfurlmessage");
 class EditorClient {
     constructor() {
         this.nextId = 0;
@@ -95,6 +99,15 @@ class EditorClient {
             'json': result['j'],
         };
     }
+    async awaitDataImport(dataConnectorName, syncDataSourceId, syncCollectionId, primaryKeys, timeout = 30000) {
+        return new collectionproxy_1.CollectionProxy(await this.sendCommand("ai" /* AwaitImport */, {
+            'n': dataConnectorName,
+            's': syncDataSourceId,
+            'c': syncCollectionId,
+            'pk': primaryKeys,
+            't': timeout,
+        }), this);
+    }
     /**
      * Make a network request
      * @param request Settings for the network request
@@ -198,6 +211,37 @@ class EditorClient {
             }));
         });
     }
+    /**
+     * @ignore
+     * Registers an handler for link unfurling.
+     * @param domain The domain
+     * @param callbacks The callbacks to call when a link matching the domain is pasted.
+     */
+    experimentalRegisterUnfurlHandler(domain, callbacks) {
+        const action = this.getUniqueActionName();
+        this.registerAction(action, async (rawMsg) => {
+            const msg = (0, registerunfurlmessage_1.deserializeRegisterUnfurlMessage)(rawMsg);
+            switch (msg.unfurlCallbackType) {
+                case unfurlcallbacks_1.UnfurlCallbackType.Unfurl: {
+                    const result = await callbacks.unfurlCallback(msg.url);
+                    if (result) {
+                        return (0, unfurldetails_1.serializeUnfurlDetails)(result);
+                    }
+                    break;
+                }
+                case unfurlcallbacks_1.UnfurlCallbackType.AfterUnfurl: {
+                    throw new Error('UnfurlCallbackType afterUnfurl not implmeneted');
+                }
+                case unfurlcallbacks_1.UnfurlCallbackType.Refresh: {
+                    throw new Error('UnfurlCallbackType refresh not implmeneted');
+                }
+                default:
+                    break;
+            }
+            return undefined;
+        });
+        this.sendCommand("ru" /* RegisterUnfurl */, { 'd': domain, 'a': action });
+    }
     /**
      * Remove the callback for a given action. If the action is later invoked, nothing will happen.
      * @param name name of the action to unregister

package/sdk/index.d.ts

@@ -4,6 +4,7 @@ export * from './core/jsonserializable';
 export * from './core/offsettype';
 export * from './core/serializeddataerror';
 export * from './core/shapedatainheritance';
+export * from './core/unfurl/unfurldetails';
 export * from './data/collectionproxy';
 export * from './data/dataerror';
 export * from './data/dataitemproxy';

package/sdk/index.js

@@ -16,6 +16,7 @@ __exportStar(require("./core/jsonserializable"), exports);
 __exportStar(require("./core/offsettype"), exports);
 __exportStar(require("./core/serializeddataerror"), exports);
 __exportStar(require("./core/shapedatainheritance"), exports);
+__exportStar(require("./core/unfurl/unfurldetails"), exports);
 __exportStar(require("./data/collectionproxy"), exports);
 __exportStar(require("./data/dataerror"), exports);
 __exportStar(require("./data/dataitemproxy"), exports);

package/sdk/message/registerunfurlmessage.d.ts

@@ -0,0 +1,28 @@
+import { JsonObject } from '../../lucid-extension-sdk';
+import { isString } from '../core/checks';
+import { UnfurlCallbackType } from '../core/unfurl/unfurlcallbacks';
+/** @ignore */
+export interface RegisterUnfurlMessage {
+    /** @ignore */
+    id: string;
+    /** @ignore */
+    url: string;
+    /** @ignore */
+    unfurlCallbackType: UnfurlCallbackType;
+}
+/** @ignore */
+export interface SerializedRegisterUnfurlMessage extends JsonObject {
+    'id': string;
+    'u': string;
+    't': UnfurlCallbackType;
+}
+/** @ignore */
+export declare const isValidRegisterUnfurlMessage: (subject: unknown) => subject is import("../core/guards").DestructureGuardedTypeObj<{
+    id: typeof isString;
+    u: typeof isString;
+    t: (x: unknown) => x is UnfurlCallbackType;
+}>;
+/** @ignore */
+export declare function deserializeRegisterUnfurlMessage(raw: SerializedRegisterUnfurlMessage): RegisterUnfurlMessage;
+/** @ignore */
+export declare function serializeRegisterUnfurlMessage(concrete: RegisterUnfurlMessage): SerializedRegisterUnfurlMessage;

package/sdk/message/registerunfurlmessage.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeRegisterUnfurlMessage = exports.deserializeRegisterUnfurlMessage = exports.isValidRegisterUnfurlMessage = void 0;
+const checks_1 = require("../core/checks");
+const unfurlcallbacks_1 = require("../core/unfurl/unfurlcallbacks");
+const validators_1 = require("../core/validators/validators");
+/** @ignore */
+exports.isValidRegisterUnfurlMessage = (0, validators_1.objectValidator)({
+    'id': checks_1.isString,
+    'u': checks_1.isString,
+    't': (0, validators_1.stringEnumValidator)(unfurlcallbacks_1.UnfurlCallbackType),
+});
+/** @ignore */
+function deserializeRegisterUnfurlMessage(raw) {
+    return {
+        id: raw['id'],
+        url: raw['u'],
+        unfurlCallbackType: raw['t'],
+    };
+}
+exports.deserializeRegisterUnfurlMessage = deserializeRegisterUnfurlMessage;
+/** @ignore */
+function serializeRegisterUnfurlMessage(concrete) {
+    return {
+        'id': concrete.id,
+        'u': concrete.url,
+        't': concrete.unfurlCallbackType,
+    };
+}
+exports.serializeRegisterUnfurlMessage = serializeRegisterUnfurlMessage;

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

@@ -1,85 +0,0 @@
-import { CollectionProxy } from '../../data/collectionproxy';
-/**
- * When this field is displayed on a card shape, how should it be displayed?
- */
-export declare enum CardFieldDisplayType {
-    Text = 1,
-    TextBadge = 2,
-    ImageBadge = 3
-}
-export declare enum CardFieldDataType {
-    Text = 1,
-    Number = 2,
-    /** An enumerated list of options, stored as a string */
-    Option = 3,
-    Checkbox = 4
-}
-/** For fields with Option or ApiOption type, the label and value for each available option */
-export interface ExtensionCardFieldOption {
-    label: string;
-    value: string;
-}
-export interface ExtensionCardFieldDefinition {
-    /** Data identifier */
-    fieldName: string;
-    /** The text to display on the menu item */
-    label: string;
-    /** Additional information we can provide to users */
-    description?: string;
-    /** How a field is displayed */
-    displayType: CardFieldDisplayType;
-    /** Data type backing the field */
-    dataType: CardFieldDataType;
-    /** If dataType is Option, the list of options available to choose from */
-    options?: ExtensionCardFieldOption[];
-}
-/** @ignore */
-export declare type SerializedCardFieldOption = {
-    'l': string;
-    'v': string;
-};
-/** @ignore */
-export declare function serializeCardFieldOption(option: ExtensionCardFieldOption): SerializedCardFieldOption;
-/** @ignore */
-export declare type SerializedExtensionCardFieldDefinition = {
-    'n': string;
-    't': string;
-    'd'?: string;
-    'diT': number;
-    'daT': number;
-    'op'?: SerializedCardFieldOption[];
-};
-/** @ignore */
-export declare function serializeCardFieldDefinition(field: ExtensionCardFieldDefinition): SerializedExtensionCardFieldDefinition;
-/** @ignore */
-export declare function serializeCardFieldArrayDefinition(fields: ExtensionCardFieldDefinition[]): SerializedExtensionCardFieldDefinition[];
-/** @ignore */
-export declare function deseializeFieldOption(option: SerializedCardFieldOption): ExtensionCardFieldOption;
-/** @ignore */
-export declare function deserializeCardFieldDefinition(field: SerializedExtensionCardFieldDefinition): ExtensionCardFieldDefinition;
-/** @ignore */
-export declare function deserializeCardFieldArrayDefinition(fields: SerializedExtensionCardFieldDefinition[]): ExtensionCardFieldDefinition[];
-export interface CardIntegration {
-    /**
-     * Label used to identify the integration, e.g. "Jira", which will be used in menu items, etc.
-     * Should be unique within any given extension.
-     */
-    label: string;
-    /**
-     * URL for an icon to display in toolbars, etc. Should be at least 24x24.
-     */
-    iconUrl: string;
-    /**
-     * Callback to provide a list of field definitions for the given collection, if that collection
-     * was imported as part of this card integration.
-     *
-     * Any fields on the schema of the collection that you don't provide a ExtensionCardFieldDefinition
-     * for will have a default definition generated based on the type specified in the schema.
-     */
-    getAllFields: (collection: CollectionProxy) => Promise<ExtensionCardFieldDefinition[]>;
-    /**
-     * 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.
-     */
-    showIntro?: () => void;
-}