lucid-extension-sdk 0.0.45 → 0.0.49

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "lucid-extension-sdk",
-    "version": "0.0.45",
+    "version": "0.0.49",
     "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

@@ -0,0 +1,88 @@
+import { HorizontalBadgePos, VerticalBadgePos } from '../properties/datagraphic/badgeposition';
+/**
+ * When configuring a field on a LucidCardBlock to be displayed as a data graphic, one of these values specifies
+ * the function to convert the field value to the data graphic settings. The definition of these functions is in
+ * LucidCardsLibrary.registerStencilDisplayTypes.
+ */
+export declare enum FieldDisplayType {
+    /**
+     * Text badge with the full text of the field.
+     * Black text on a light gray background in the upper-right of the card.
+     */
+    BasicTextBadge = "BasicTextBadge",
+    /**
+     * Given a name (usually of a user), puts a text badge with their initials (first letter of each name)
+     * at the bottom-left of the card, black text on a light gray background.
+     */
+    InitializedString = "InitializedString",
+    /**
+     * Given a number, display the number in the bottom-left of the card. If the number is higher than 999,
+     * display 999.
+     */
+    StandardEstimation = "StandardEstimation"
+}
+export declare const isFieldDisplayType: (x: unknown) => x is FieldDisplayType;
+/**
+ * When configuring a field on a LucidCardBlock to be displayed as a data graphic, this click handler value
+ * specifies what to do when the user clicks on the data graphic produced.
+ */
+export declare enum OnClickHandlerKeys {
+    /**
+     * Display the UI panel to edit fields on the data associated with the card
+     */
+    BasicEditPanel = "BasicEditPanel"
+}
+export declare const isOnClickHandlerKey: (x: unknown) => x is OnClickHandlerKeys.BasicEditPanel;
+export interface StencilConfig {
+    /**
+     * How should we generate the stencil/data graphic from the specified field value?
+     * These are registered in LucidCardsLibrary.registerStencilDisplayTypes.
+     */
+    displayType: FieldDisplayType;
+    /**
+     * For displayType values that support it, you may provide an override for the
+     * background color for this data. If this is not provided, the background color
+     * will default to the background color of the card itself, darkened 5%.
+     *
+     * 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)"
+     */
+    backgroundColor?: string;
+    /**
+     * Each display type has its default location on the card. You can override those
+     * default locations by setting these values.
+     */
+    horizontalPosition?: HorizontalBadgePos;
+    /**
+     * Each display type has its default location on the card. You can override those
+     * default locations by setting these values.
+     */
+    verticalPosition?: VerticalBadgePos;
+    /**
+     * If specified, what behavior should happen when the user clicks on the data graphic
+     * generated via the above displayType?
+     */
+    onClickHandlerKey?: OnClickHandlerKeys;
+}
+/**
+ * Configuration settings for how to display a particular field on the card itself.
+ * Currently only used for adding custom data graphics with stencils.
+ */
+export interface LucidCardFieldDisplaySettings {
+    stencilConfig?: StencilConfig;
+}
+/** @ignore */
+export declare type SerializedLucidCardFieldDisplaySettings = {
+    'StencilConfig'?: {
+        /** Since renamed to displayType, but we can't change the serialized name */
+        'getterKey': FieldDisplayType;
+        'bg'?: string;
+        'h'?: HorizontalBadgePos;
+        'v'?: VerticalBadgePos;
+        'onClickHandlerKey'?: OnClickHandlerKeys;
+    };
+};
+/** @ignore */
+export declare function serializeLucidCardFieldDisplaySettings(settings: LucidCardFieldDisplaySettings): SerializedLucidCardFieldDisplaySettings;
+/** @ignore */
+export declare function deserializeLucidCardFieldDisplaySettings(settings: SerializedLucidCardFieldDisplaySettings): LucidCardFieldDisplaySettings;

package/sdk/core/cardintegration/cardfielddisplaysettings.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeLucidCardFieldDisplaySettings = exports.serializeLucidCardFieldDisplaySettings = exports.isOnClickHandlerKey = exports.OnClickHandlerKeys = exports.isFieldDisplayType = exports.FieldDisplayType = void 0;
+const validators_1 = require("../validators/validators");
+/**
+ * When configuring a field on a LucidCardBlock to be displayed as a data graphic, one of these values specifies
+ * the function to convert the field value to the data graphic settings. The definition of these functions is in
+ * LucidCardsLibrary.registerStencilDisplayTypes.
+ */
+var FieldDisplayType;
+(function (FieldDisplayType) {
+    /**
+     * Text badge with the full text of the field.
+     * Black text on a light gray background in the upper-right of the card.
+     */
+    FieldDisplayType["BasicTextBadge"] = "BasicTextBadge";
+    /**
+     * Given a name (usually of a user), puts a text badge with their initials (first letter of each name)
+     * at the bottom-left of the card, black text on a light gray background.
+     */
+    FieldDisplayType["InitializedString"] = "InitializedString";
+    /**
+     * Given a number, display the number in the bottom-left of the card. If the number is higher than 999,
+     * display 999.
+     */
+    FieldDisplayType["StandardEstimation"] = "StandardEstimation";
+})(FieldDisplayType = exports.FieldDisplayType || (exports.FieldDisplayType = {}));
+exports.isFieldDisplayType = (0, validators_1.enumValidator)(FieldDisplayType);
+/**
+ * When configuring a field on a LucidCardBlock to be displayed as a data graphic, this click handler value
+ * specifies what to do when the user clicks on the data graphic produced.
+ */
+var OnClickHandlerKeys;
+(function (OnClickHandlerKeys) {
+    /**
+     * Display the UI panel to edit fields on the data associated with the card
+     */
+    OnClickHandlerKeys["BasicEditPanel"] = "BasicEditPanel";
+})(OnClickHandlerKeys = exports.OnClickHandlerKeys || (exports.OnClickHandlerKeys = {}));
+exports.isOnClickHandlerKey = (0, validators_1.enumValidator)(OnClickHandlerKeys);
+/** @ignore */
+function serializeLucidCardFieldDisplaySettings(settings) {
+    return {
+        'StencilConfig': settings.stencilConfig && {
+            'getterKey': settings.stencilConfig.displayType,
+            'bg': settings.stencilConfig.backgroundColor,
+            'h': settings.stencilConfig.horizontalPosition,
+            'v': settings.stencilConfig.verticalPosition,
+            'onClickHandlerKey': settings.stencilConfig.onClickHandlerKey,
+        },
+    };
+}
+exports.serializeLucidCardFieldDisplaySettings = serializeLucidCardFieldDisplaySettings;
+/** @ignore */
+function deserializeLucidCardFieldDisplaySettings(settings) {
+    return {
+        stencilConfig: settings['StencilConfig'] && {
+            displayType: settings['StencilConfig']['getterKey'],
+            backgroundColor: settings['StencilConfig']['bg'],
+            horizontalPosition: settings['StencilConfig']['h'],
+            verticalPosition: settings['StencilConfig']['v'],
+            onClickHandlerKey: settings['StencilConfig']['onClickHandlerKey'],
+        },
+    };
+}
+exports.deserializeLucidCardFieldDisplaySettings = deserializeLucidCardFieldDisplaySettings;

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

@@ -5,6 +5,7 @@ import { isString } from '../checks';
 import { isSerializedFieldTypeDefinition } from '../data/fieldtypedefinition/fieldtypedefinition';
 import { FieldConstraintType, SerializedFieldDefinition } from '../data/serializedfield/serializedfielddefinition';
 import { isSerializedFieldType, SerializedFieldType } from '../data/serializedfield/serializedfields';
+import { CardIntegrationConfig } from './cardintegrationconfig';
 /** For fields with Option or ApiOption type, the label and value for each available option */
 export interface ExtensionCardFieldOption {
     label: string;
@@ -72,25 +73,6 @@ export declare const isSerializedExtensionCardFieldDefinition: (subject: unknown
 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.

package/sdk/core/cardintegration/cardintegration.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deserializeCardIntegrationConfig = exports.serializeCardIntegrationConfig = exports.deserializeCardFieldArrayDefinition = exports.deserializeCardFieldDefinition = exports.isSerializedExtensionCardFieldDefinition = exports.isSerializedFieldConstraint = exports.isSerializedFieldOptions = exports.isSerializedFieldOption = exports.deserializeFieldOption = exports.serializeCardFieldArrayDefinition = exports.serializeCardFieldDefinition = exports.serializeCardFieldOption = void 0;
+exports.deserializeCardFieldArrayDefinition = exports.deserializeCardFieldDefinition = exports.isSerializedExtensionCardFieldDefinition = exports.isSerializedFieldConstraint = exports.isSerializedFieldOptions = exports.isSerializedFieldOption = exports.deserializeFieldOption = exports.serializeCardFieldArrayDefinition = exports.serializeCardFieldDefinition = exports.serializeCardFieldOption = void 0;
 const schemadefinition_1 = require("../../data/schemadefinition");
 const checks_1 = require("../checks");
 const fieldtypedefinition_1 = require("../data/fieldtypedefinition/fieldtypedefinition");
@@ -64,19 +64,3 @@ 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/cardintegration/cardintegrationconfig.d.ts

@@ -0,0 +1,25 @@
+import { LucidCardFieldDisplaySettings, SerializedLucidCardFieldDisplaySettings } from './cardfielddisplaysettings';
+export interface CardIntegrationConfig {
+    /**
+     * The data fields to be displayed on cards, as data-linked text fields
+     */
+    fieldNames: string[];
+    /**
+     * The data fields to be displayed on cards as data graphics
+     */
+    fieldDisplaySettings?: Map<string, LucidCardFieldDisplaySettings>;
+    /**
+     * The field name to use as the displayed ID of the card, if any
+     */
+    idFieldName?: string;
+}
+/** @ignore */
+export declare type SerializedCardIntegrationConfig = {
+    'f': string[];
+    'fd'?: [string, SerializedLucidCardFieldDisplaySettings][];
+    'id'?: string;
+};
+/** @ignore */
+export declare function serializeCardIntegrationConfig(config: CardIntegrationConfig): SerializedCardIntegrationConfig;
+/** @ignore */
+export declare function deserializeCardIntegrationConfig(raw: SerializedCardIntegrationConfig): CardIntegrationConfig;

package/sdk/core/cardintegration/cardintegrationconfig.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeCardIntegrationConfig = exports.serializeCardIntegrationConfig = void 0;
+const cardfielddisplaysettings_1 = require("./cardfielddisplaysettings");
+/** @ignore */
+function serializeCardIntegrationConfig(config) {
+    return {
+        'f': config.fieldNames,
+        'fd': config.fieldDisplaySettings
+            ? [...config.fieldDisplaySettings].map(([key, settings]) => [
+                key,
+                (0, cardfielddisplaysettings_1.serializeLucidCardFieldDisplaySettings)(settings),
+            ])
+            : undefined,
+        'id': config.idFieldName,
+    };
+}
+exports.serializeCardIntegrationConfig = serializeCardIntegrationConfig;
+/** @ignore */
+function deserializeCardIntegrationConfig(raw) {
+    return {
+        fieldNames: raw['f'],
+        fieldDisplaySettings: raw['fd']
+            ? new Map(raw['fd'].map(([key, settings]) => [key, (0, cardfielddisplaysettings_1.deserializeLucidCardFieldDisplaySettings)(settings)]))
+            : undefined,
+        idFieldName: raw['id'],
+    };
+}
+exports.deserializeCardIntegrationConfig = deserializeCardIntegrationConfig;

package/sdk/core/checks.d.ts

@@ -99,3 +99,14 @@ export declare function isEmptyOrNullishObject(val: unknown): val is {};
 export declare function isAny(val: unknown): val is any;
 export declare function isUnknown(val: unknown): val is unknown;
 export declare function isPromise(val: unknown): val is Promise<unknown>;
+export declare function isLiteral<T extends string | number | symbol>(t: T): (x: unknown) => x is T;
+declare type AbstractConstructor<T> = Function & {
+    prototype: T;
+};
+/**
+ * Since `instanceof` should generally be avoided, this function should generally be avoided as well.
+ *
+ * A valid use case is for native types, like Uint8Array.
+ */
+export declare function isInstanceOf<T>(klass: AbstractConstructor<T>): (x: unknown) => x is T;
+export {};

package/sdk/core/checks.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isPromise = exports.isUnknown = exports.isAny = exports.isEmptyOrNullishObject = exports.isTypedArray = exports.isArray = exports.isRecord = exports.isObject = exports.isFunction = exports.isInt = exports.isNumber = exports.isBoolean = exports.isString = exports.isNullish = exports.isDefAndNotNull = exports.isUndefined = exports.isNull = exports.isDef = void 0;
+exports.isInstanceOf = exports.isLiteral = exports.isPromise = exports.isUnknown = exports.isAny = exports.isEmptyOrNullishObject = exports.isTypedArray = exports.isArray = exports.isRecord = exports.isObject = exports.isFunction = exports.isInt = exports.isNumber = exports.isBoolean = exports.isString = exports.isNullish = exports.isDefAndNotNull = exports.isUndefined = exports.isNull = exports.isDef = void 0;
 /**
  * Returns true if the specified value is not undefined.
  *
@@ -163,3 +163,16 @@ function isPromise(val) {
     return isObject(val) && isFunction(val['then']) && isFunction(val['catch']);
 }
 exports.isPromise = isPromise;
+function isLiteral(t) {
+    return (x) => x === t;
+}
+exports.isLiteral = isLiteral;
+/**
+ * Since `instanceof` should generally be avoided, this function should generally be avoided as well.
+ *
+ * A valid use case is for native types, like Uint8Array.
+ */
+function isInstanceOf(klass) {
+    return (x) => x instanceof klass;
+}
+exports.isInstanceOf = isInstanceOf;

package/sdk/core/data/fieldtypedefinition/basefieldtypedefinition.d.ts

@@ -4,8 +4,7 @@ import { LiteralFieldType, SerializedLiteralFieldType } from './literalfieldtype
 import { NDimensionalFieldTypeArray, SerializedNDimensionalFieldTypeArray } from './ndimensionalfieldtypearray';
 import { ScalarFieldTypeEnum } from './scalarfieldtype';
 export declare type AnyFieldTypeArrayDefinition = FieldTypeArray | NDimensionalFieldTypeArray;
-export declare function isAnyFieldTypeArray(fieldType: BaseFieldTypeDefinition): fieldType is AnyFieldTypeArrayDefinition;
-export declare type BaseFieldTypeDefinition = ScalarFieldTypeEnum | LiteralFieldType | AnyFieldTypeArrayDefinition | CollectionEnumFieldType;
+export declare type BaseFieldTypeDefinition = ScalarFieldTypeEnum | LiteralFieldType | FieldTypeArray | NDimensionalFieldTypeArray | CollectionEnumFieldType;
 export declare type SerializedBaseFieldTypeDefinition = ScalarFieldTypeEnum | SerializedLiteralFieldType | SerializedFieldTypeArray | SerializedNDimensionalFieldTypeArray | SerializedCollectionEnumFieldType;
 export declare function isBaseFieldTypeDefinition(fieldType: any): fieldType is BaseFieldTypeDefinition;
 export declare function serializeBaseFieldTypeDefinition(baseFieldType: BaseFieldTypeDefinition): SerializedBaseFieldTypeDefinition;

package/sdk/core/data/fieldtypedefinition/basefieldtypedefinition.js

@@ -1,20 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isSerializedBaseFieldTypeDefinition = exports.deserializeBaseFieldTypeDefinition = exports.serializeBaseFieldTypeDefinition = exports.isBaseFieldTypeDefinition = exports.isAnyFieldTypeArray = void 0;
+exports.isSerializedBaseFieldTypeDefinition = exports.deserializeBaseFieldTypeDefinition = exports.serializeBaseFieldTypeDefinition = exports.isBaseFieldTypeDefinition = void 0;
 const checks_1 = require("../../checks");
 const collectionenumfieldtype_1 = require("./collectionenumfieldtype");
 const fieldtypearray_1 = require("./fieldtypearray");
 const literalfieldtype_1 = require("./literalfieldtype");
 const ndimensionalfieldtypearray_1 = require("./ndimensionalfieldtypearray");
 const scalarfieldtype_1 = require("./scalarfieldtype");
-function isAnyFieldTypeArray(fieldType) {
-    return fieldType instanceof fieldtypearray_1.FieldTypeArray || fieldType instanceof ndimensionalfieldtypearray_1.NDimensionalFieldTypeArray;
-}
-exports.isAnyFieldTypeArray = isAnyFieldTypeArray;
 function isBaseFieldTypeDefinition(fieldType) {
     return ((0, scalarfieldtype_1.isScalarFieldTypeEnum)(fieldType) ||
         (0, literalfieldtype_1.isLiteralFieldType)(fieldType) ||
-        isAnyFieldTypeArray(fieldType) ||
+        fieldType instanceof fieldtypearray_1.FieldTypeArray ||
+        fieldType instanceof ndimensionalfieldtypearray_1.NDimensionalFieldTypeArray ||
         (0, collectionenumfieldtype_1.isCollectionEnumFieldType)(fieldType));
 }
 exports.isBaseFieldTypeDefinition = isBaseFieldTypeDefinition;

package/sdk/core/data/fieldtypedefinition/collectionenumfieldtype.d.ts

@@ -1,3 +1,4 @@
+import { FieldTypeDefinition } from './fieldtypedefinition';
 export declare const CollectionEnumFieldTypeKey = "COLLECTION_ENUM";
 /**
  * Contains the field names of all valid fields for a groovy metadata collection.
@@ -22,7 +23,7 @@ export declare class CollectionEnumFieldType {
     constructor(collectionId: string);
     serialize(): SerializedCollectionEnumFieldType;
 }
-export declare const isCollectionEnumFieldType: (fieldType: any) => fieldType is CollectionEnumFieldType;
+export declare const isCollectionEnumFieldType: (fieldType: FieldTypeDefinition) => fieldType is CollectionEnumFieldType;
 export declare type SerializedCollectionEnumFieldType = {
     [CollectionEnumFieldTypeKey]: string;
 };

package/sdk/core/data/fieldtypedefinition/fieldtypearray.d.ts

@@ -1,14 +1,18 @@
 import { CollectionEnumFieldType, SerializedCollectionEnumFieldType } from './collectionenumfieldtype';
 import { LiteralFieldType, SerializedLiteralFieldType } from './literalfieldtype';
 import { ScalarFieldTypeEnum } from './scalarfieldtype';
-export declare class FieldTypeArray {
-    readonly validTypesArray: (ScalarFieldTypeEnum | CollectionEnumFieldType | LiteralFieldType | FieldTypeArray)[];
-    constructor(validTypesArray: (ScalarFieldTypeEnum | CollectionEnumFieldType | LiteralFieldType | FieldTypeArray)[]);
-    getInnerTypes(): (CollectionEnumFieldType | ScalarFieldTypeEnum | LiteralFieldType | FieldTypeArray)[];
-    getInnerNonArrayTypes(): (CollectionEnumFieldType | ScalarFieldTypeEnum | LiteralFieldType | FieldTypeArray)[];
+export declare abstract class BaseFieldTypeArray<Type> {
+    readonly validTypesArray: Type[];
+    constructor(validTypesArray: Type[]);
+    protected abstract serializeType(t: Type): SerializedFieldTypeArray['validTypes']['0'];
+    getInnerTypes(): Type[];
+    getInnerNonArrayTypes(): Exclude<Type, BaseFieldTypeArray<Type>>[];
     serialize(): SerializedFieldTypeArray;
 }
-export declare function isValidTypeForFieldTypeArray(fieldType: any): fieldType is ScalarFieldTypeEnum | LiteralFieldType | CollectionEnumFieldType | FieldTypeArray;
+export declare type FieldTypeArraySubTypes = ScalarFieldTypeEnum | CollectionEnumFieldType | LiteralFieldType | FieldTypeArray;
+export declare class FieldTypeArray extends BaseFieldTypeArray<FieldTypeArraySubTypes> {
+    protected serializeType(t: FieldTypeArraySubTypes): string | SerializedCollectionEnumFieldType | ScalarFieldTypeEnum | SerializedFieldTypeArray;
+}
 export declare type SerializedFieldTypeArray = {
     'ND': false;
     'validTypes': (ScalarFieldTypeEnum | SerializedLiteralFieldType | SerializedFieldTypeArray | SerializedCollectionEnumFieldType)[];

package/sdk/core/data/fieldtypedefinition/fieldtypearray.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deserializeFieldTypeArray = exports.isSerializedFieldTypeArray = exports.isValidTypeForFieldTypeArray = exports.FieldTypeArray = void 0;
+exports.deserializeFieldTypeArray = exports.isSerializedFieldTypeArray = exports.FieldTypeArray = exports.BaseFieldTypeArray = void 0;
 const checks_1 = require("../../checks");
 const collectionenumfieldtype_1 = require("./collectionenumfieldtype");
 const literalfieldtype_1 = require("./literalfieldtype");
 const scalarfieldtype_1 = require("./scalarfieldtype");
-class FieldTypeArray {
+class BaseFieldTypeArray {
     constructor(validTypesArray) {
         this.validTypesArray = validTypesArray;
     }
@@ -13,23 +13,22 @@ class FieldTypeArray {
         return this.validTypesArray;
     }
     getInnerNonArrayTypes() {
-        return this.validTypesArray.filter((innerType) => (0, scalarfieldtype_1.isScalarFieldTypeEnum)(innerType) || (0, literalfieldtype_1.isLiteralFieldType)(innerType));
+        return this.validTypesArray.filter((innerType) => !(innerType instanceof BaseFieldTypeArray));
     }
     serialize() {
         return {
             'ND': false,
-            'validTypes': this.validTypesArray.map((t) => ((0, scalarfieldtype_1.isScalarFieldTypeEnum)(t) ? t : t.serialize())),
+            'validTypes': this.validTypesArray.map((t) => this.serializeType(t)),
         };
     }
 }
-exports.FieldTypeArray = FieldTypeArray;
-function isValidTypeForFieldTypeArray(fieldType) {
-    return ((0, scalarfieldtype_1.isScalarFieldTypeEnum)(fieldType) ||
-        (0, literalfieldtype_1.isLiteralFieldType)(fieldType) ||
-        (0, collectionenumfieldtype_1.isCollectionEnumFieldType)(fieldType) ||
-        fieldType instanceof FieldTypeArray);
+exports.BaseFieldTypeArray = BaseFieldTypeArray;
+class FieldTypeArray extends BaseFieldTypeArray {
+    serializeType(t) {
+        return (0, scalarfieldtype_1.isScalarFieldTypeEnum)(t) ? t : t.serialize();
+    }
 }
-exports.isValidTypeForFieldTypeArray = isValidTypeForFieldTypeArray;
+exports.FieldTypeArray = FieldTypeArray;
 function isSerializedFieldTypeArray(fieldType, validateTypeCheck) {
     return ((0, checks_1.isObject)(fieldType) &&
         (0, checks_1.isBoolean)(fieldType['ND']) &&

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

@@ -1,13 +1,8 @@
 import { BaseFieldTypeDefinition, SerializedBaseFieldTypeDefinition } from './basefieldtypedefinition';
-import { NDimensionalFieldTypeArray } from './ndimensionalfieldtypearray';
-import { ScalarFieldTypeEnum } from './scalarfieldtype';
 export declare type FieldTypeDefinition = BaseFieldTypeDefinition | BaseFieldTypeDefinition[];
 export declare function fieldTypesEqual(a: FieldTypeDefinition, b: FieldTypeDefinition, checkEnumCollectionId?: boolean): boolean;
-export declare function isSubtypeOfFieldType(subType: FieldTypeDefinition, superTypes: FieldTypeDefinition): boolean;
-export declare const AnyFieldType: (ScalarFieldTypeEnum | NDimensionalFieldTypeArray)[];
-export declare function isAnyFieldType(type: FieldTypeDefinition): boolean;
-export declare const serializeFieldTypeDefinition: (fieldType: FieldTypeDefinition) => SerializedFieldTypeDefinition;
+export declare function serializeFieldTypeDefinition(fieldType: BaseFieldTypeDefinition): SerializedBaseFieldTypeDefinition;
+export declare function serializeFieldTypeDefinition(fieldType: FieldTypeDefinition): SerializedFieldTypeDefinition;
 export declare const deserializeFieldTypeDefinition: (serializedFieldType: SerializedFieldTypeDefinition) => FieldTypeDefinition;
-export declare const SerializedAnyFieldType: SerializedFieldTypeDefinition;
 export declare type SerializedFieldTypeDefinition = SerializedBaseFieldTypeDefinition | SerializedBaseFieldTypeDefinition[];
 export declare function isSerializedFieldTypeDefinition(definition: any): definition is SerializedFieldTypeDefinition;

package/sdk/core/data/fieldtypedefinition/fieldtypedefinition.js

@@ -1,13 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isSerializedFieldTypeDefinition = exports.SerializedAnyFieldType = exports.deserializeFieldTypeDefinition = exports.serializeFieldTypeDefinition = exports.isAnyFieldType = exports.AnyFieldType = exports.isSubtypeOfFieldType = exports.fieldTypesEqual = void 0;
+exports.isSerializedFieldTypeDefinition = exports.deserializeFieldTypeDefinition = exports.serializeFieldTypeDefinition = exports.fieldTypesEqual = void 0;
 const checks_1 = require("../../checks");
 const basefieldtypedefinition_1 = require("./basefieldtypedefinition");
 const collectionenumfieldtype_1 = require("./collectionenumfieldtype");
 const fieldtypearray_1 = require("./fieldtypearray");
 const literalfieldtype_1 = require("./literalfieldtype");
 const ndimensionalfieldtypearray_1 = require("./ndimensionalfieldtypearray");
-const scalarfieldtype_1 = require("./scalarfieldtype");
 function fieldTypesEqual(a, b, checkEnumCollectionId = true) {
     if (a === b) {
         return true;
@@ -54,90 +53,14 @@ function fieldTypesEqual(a, b, checkEnumCollectionId = true) {
     return true;
 }
 exports.fieldTypesEqual = fieldTypesEqual;
-function isSubtypeOfFieldType(subType, superTypes) {
-    if (!(0, checks_1.isArray)(superTypes)) {
-        superTypes = [superTypes];
-    }
-    if ((0, checks_1.isArray)(subType)) {
-        return subType.every((one) => isSubtypeOfFieldType(one, superTypes));
-    }
-    if (superTypes.includes(scalarfieldtype_1.ScalarFieldTypeEnum.ANY)) {
-        return true;
-    }
-    if ((0, scalarfieldtype_1.isScalarFieldTypeEnum)(subType)) {
-        return superTypes.includes(subType);
-    }
-    if ((0, literalfieldtype_1.isLiteralFieldType)(subType)) {
-        if (superTypes.includes(subType.getScalarFieldType())) {
-            return true;
-        }
-        const superLiteralTypes = superTypes.filter(literalfieldtype_1.isLiteralFieldType);
-        if (superLiteralTypes.find((superLiteralType) => subType.getLiteral() === superLiteralType.getLiteral())) {
-            return true;
-        }
-        const superArrayTypes = superTypes.filter(basefieldtypedefinition_1.isAnyFieldTypeArray);
-        for (const superArrayType of superArrayTypes) {
-            if (isSubtypeOfFieldType(subType, superArrayType.getInnerTypes())) {
-                return true;
-            }
-        }
-        return false;
-    }
-    if ((0, collectionenumfieldtype_1.isCollectionEnumFieldType)(subType)) {
-        return superTypes.filter(collectionenumfieldtype_1.isCollectionEnumFieldType).some((ce) => ce.collectionId === subType.collectionId);
-    }
-    if ((0, ndimensionalfieldtypearray_1.isNDimensionalFieldTypeArray)(subType)) {
-        const superNArrayTypes = superTypes.filter(ndimensionalfieldtypearray_1.isNDimensionalFieldTypeArray);
-        return !!superNArrayTypes.find((superNArrayType) => isSubtypeOfFieldType(subType.validTypesArray, superNArrayType.validTypesArray));
-    }
-    const subTypeArrayInnerTypes = subType.getInnerTypes();
-    const superArrayTypes = superTypes.filter(basefieldtypedefinition_1.isAnyFieldTypeArray);
-    for (const superArrayType of superArrayTypes) {
-        if (isSubtypeOfFieldType(subTypeArrayInnerTypes, superArrayType.getInnerTypes())) {
-            return true;
-        }
-    }
-    return false;
-}
-exports.isSubtypeOfFieldType = isSubtypeOfFieldType;
-exports.AnyFieldType = [...scalarfieldtype_1.AnyScalarFieldType, new ndimensionalfieldtypearray_1.NDimensionalFieldTypeArray(scalarfieldtype_1.AnyScalarFieldType)];
-function isAnyFieldType(type) {
-    let nArray;
-    if (type === scalarfieldtype_1.ScalarFieldTypeEnum.ANY ||
-        type === exports.AnyFieldType ||
-        ((0, checks_1.isArray)(type) &&
-            type.includes(scalarfieldtype_1.ScalarFieldTypeEnum.NUMBER) &&
-            type.includes(scalarfieldtype_1.ScalarFieldTypeEnum.STRING) &&
-            type.includes(scalarfieldtype_1.ScalarFieldTypeEnum.BOOLEAN) &&
-            type.includes(scalarfieldtype_1.ScalarFieldTypeEnum.COLOR) &&
-            type.includes(scalarfieldtype_1.ScalarFieldTypeEnum.DATE) &&
-            type.includes(scalarfieldtype_1.ScalarFieldTypeEnum.NULL) &&
-            type.includes(scalarfieldtype_1.ScalarFieldTypeEnum.DICTIONARY) &&
-            type.includes(scalarfieldtype_1.ScalarFieldTypeEnum.CURRENCY) &&
-            !type.some(literalfieldtype_1.isLiteralFieldType) &&
-            (nArray = type.find(ndimensionalfieldtypearray_1.isNDimensionalFieldTypeArray)) &&
-            nArray.validTypesArray.includes(scalarfieldtype_1.ScalarFieldTypeEnum.NUMBER) &&
-            nArray.validTypesArray.includes(scalarfieldtype_1.ScalarFieldTypeEnum.STRING) &&
-            nArray.validTypesArray.includes(scalarfieldtype_1.ScalarFieldTypeEnum.BOOLEAN) &&
-            nArray.validTypesArray.includes(scalarfieldtype_1.ScalarFieldTypeEnum.COLOR) &&
-            nArray.validTypesArray.includes(scalarfieldtype_1.ScalarFieldTypeEnum.DATE) &&
-            nArray.validTypesArray.includes(scalarfieldtype_1.ScalarFieldTypeEnum.DICTIONARY) &&
-            nArray.validTypesArray.includes(scalarfieldtype_1.ScalarFieldTypeEnum.NULL) &&
-            nArray.validTypesArray.includes(scalarfieldtype_1.ScalarFieldTypeEnum.CURRENCY) &&
-            !nArray.validTypesArray.some(literalfieldtype_1.isLiteralFieldType))) {
-        return true;
-    }
-    return false;
-}
-exports.isAnyFieldType = isAnyFieldType;
-const serializeFieldTypeDefinition = (fieldType) => {
+function serializeFieldTypeDefinition(fieldType) {
     if ((0, checks_1.isArray)(fieldType)) {
         return fieldType.map(basefieldtypedefinition_1.serializeBaseFieldTypeDefinition);
     }
     else {
         return (0, basefieldtypedefinition_1.serializeBaseFieldTypeDefinition)(fieldType);
     }
-};
+}
 exports.serializeFieldTypeDefinition = serializeFieldTypeDefinition;
 const deserializeFieldTypeDefinition = (serializedFieldType) => {
     if ((0, checks_1.isArray)(serializedFieldType)) {
@@ -146,7 +69,6 @@ const deserializeFieldTypeDefinition = (serializedFieldType) => {
     return (0, basefieldtypedefinition_1.deserializeBaseFieldTypeDefinition)(serializedFieldType);
 };
 exports.deserializeFieldTypeDefinition = deserializeFieldTypeDefinition;
-exports.SerializedAnyFieldType = (0, exports.serializeFieldTypeDefinition)(exports.AnyFieldType);
 function isSerializedFieldTypeDefinition(definition) {
     if ((0, checks_1.isArray)(definition)) {
         return definition.every(basefieldtypedefinition_1.isSerializedBaseFieldTypeDefinition);

package/sdk/core/xhr.d.ts

@@ -0,0 +1,49 @@
+import { SendXHRResponseFormat } from '../commandtypes';
+import { Validator } from './guards';
+export interface XHRRequest {
+    /** URL to request */
+    url: string;
+    /** HTTP method, e.g. "POST". If omitted, GET is used */
+    method?: string;
+    /** The data to send as the body of the request  */
+    data?: string;
+    /** Headers to send with the request. If specifying an array, multiple headers with the same name will be sent */
+    headers?: {
+        [key: string]: string | string[];
+    };
+    /** If specified, this request should time out after the given number of milliseconds */
+    timeoutMs?: number;
+    /**
+     * The desired format for the returned response body. Defaults to 'utf8'.
+     *
+     * - If 'utf8', the response body will be returned as a string.
+     * - If 'binary', the response body will be returned as a Uint8Array.
+     */
+    responseFormat?: SendXHRResponseFormat;
+}
+export interface BaseXHRResponse {
+    /** URL of the final response, after any redirects */
+    url: string;
+    /** HTTP status, e.g. 200 or 404 */
+    status: number;
+    /** Headers sent by the server in the response */
+    headers: {
+        [key: string]: string;
+    };
+    /** True if this request failed due to a timeout */
+    timeout?: boolean;
+}
+export interface TextXHRResponse extends BaseXHRResponse {
+    responseFormat: 'utf8';
+    /** Plain text of the response body */
+    responseText: string;
+}
+export interface BinaryXHRResponse extends BaseXHRResponse {
+    responseFormat: 'binary';
+    /** Contents of the response body */
+    responseData: Uint8Array;
+}
+export declare type XHRResponse = TextXHRResponse | BinaryXHRResponse;
+export declare const isTextXHRResponse: Validator<TextXHRResponse>;
+export declare const isBinaryXHRResponse: Validator<BinaryXHRResponse>;
+export declare const isXHRResponse: Validator<XHRResponse>;

package/sdk/core/xhr.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isXHRResponse = exports.isBinaryXHRResponse = exports.isTextXHRResponse = void 0;
+const checks_1 = require("./checks");
+const validators_1 = require("./validators/validators");
+const isBaseXHRResponse = (0, validators_1.objectValidator)({
+    url: checks_1.isString,
+    status: checks_1.isNumber,
+    headers: (0, validators_1.objectOfValidator)(checks_1.isString),
+    timeout: (0, validators_1.option)(checks_1.isBoolean),
+});
+exports.isTextXHRResponse = (0, validators_1.both)(isBaseXHRResponse, (0, validators_1.objectValidator)({
+    responseFormat: (0, checks_1.isLiteral)('utf8'),
+    responseText: checks_1.isString,
+}));
+exports.isBinaryXHRResponse = (0, validators_1.both)(isBaseXHRResponse, (0, validators_1.objectValidator)({
+    responseFormat: (0, checks_1.isLiteral)('binary'),
+    responseData: (0, checks_1.isInstanceOf)(Uint8Array),
+}));
+exports.isXHRResponse = (0, validators_1.either)(exports.isTextXHRResponse, exports.isBinaryXHRResponse);

package/sdk/document/taskmanagementcardintegration.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TaskManagementCardIntegration = void 0;
 const cardintegration_1 = require("../core/cardintegration/cardintegration");
+const cardintegrationconfig_1 = require("../core/cardintegration/cardintegrationconfig");
 const collectiondefinition_1 = require("../data/collectiondefinition");
 const collectionproxy_1 = require("../data/collectionproxy");
 class TaskManagementCardIntegration {
@@ -26,7 +27,7 @@ class TaskManagementCardIntegration {
         const getDefaultConfigActionName = TaskManagementCardIntegration.nextHookName();
         this.client.registerAction(getDefaultConfigActionName, async (param) => {
             const collection = new collectionproxy_1.CollectionProxy(param['c'], this.client);
-            return (0, cardintegration_1.serializeCardIntegrationConfig)(await card.getDefaultConfig(collection));
+            return (0, cardintegrationconfig_1.serializeCardIntegrationConfig)(await card.getDefaultConfig(collection));
         });
         let showIntroActionName = undefined;
         if (card.showIntro) {

package/sdk/editorclient.d.ts

@@ -1,6 +1,7 @@
-import { CommandArgs, CommandName, SendXHRResponseFormat, UnionToIntersection } from './commandtypes';
+import { CommandArgs, CommandName, UnionToIntersection } from './commandtypes';
 import { JsonSerializable } from './core/jsonserializable';
 import { UnfurlCallbacks } from './core/unfurl/unfurlcallbacks';
+import { BinaryXHRResponse, TextXHRResponse, XHRRequest, XHRResponse } from './core/xhr';
 import { CollectionProxy } from './data/collectionproxy';
 import { BlockDefinition } from './document/blockdefinition';
 import { BlockProxy } from './document/blockproxy';
@@ -9,50 +10,6 @@ import { GroupProxy } from './document/groupproxy';
 import { LineProxy } from './document/lineproxy';
 import { PageProxy } from './document/pageproxy';
 import { FileUploadData } from './ui/menu';
-export interface XHRRequest {
-    /** URL to request */
-    url: string;
-    /** HTTP method, e.g. "POST". If omitted, GET is used */
-    method?: string;
-    /** The data to send as the body of the request  */
-    data?: string;
-    /** Headers to send with the request. If specifying an array, multiple headers with the same name will be sent */
-    headers?: {
-        [key: string]: string | string[];
-    };
-    /** If specified, this request should time out after the given number of milliseconds */
-    timeoutMs?: number;
-    /**
-     * The desired format for the returned response body. Defaults to 'utf8'.
-     *
-     * - If 'utf8', the response body will be returned as a string.
-     * - If 'binary', the response body will be returned as a Uint8Array.
-     */
-    responseFormat?: SendXHRResponseFormat;
-}
-export interface BaseXHRResponse {
-    /** URL of the final response, after any redirects */
-    url: string;
-    /** HTTP status, e.g. 200 or 404 */
-    status: number;
-    /** Headers sent by the server in the response */
-    headers: {
-        [key: string]: string;
-    };
-    /** True if this request failed due to a timeout */
-    timeout?: boolean;
-}
-export interface TextXHRResponse extends BaseXHRResponse {
-    responseFormat: 'utf8';
-    /** Plain text of the response body */
-    responseText: string;
-}
-export interface BinaryXHRResponse extends BaseXHRResponse {
-    responseFormat: 'binary';
-    /** Contents of the response body */
-    responseData: Uint8Array;
-}
-export declare type XHRResponse = TextXHRResponse | BinaryXHRResponse;
 export declare type DataActionResult = {
     /** The HTTP Status Code from the Extension Data Sync endpoint */
     'status': number;

package/sdk/editorclient.js

@@ -16,7 +16,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");
+const unfurleventmessage_1 = require("./message/unfurleventmessage");
 function parseRawXHRResponse(responseFormat, raw) {
     var _a, _b, _c, _d;
     return Object.assign({ url: (_a = raw === null || raw === void 0 ? void 0 : raw['url']) !== null && _a !== void 0 ? _a : '', status: (_b = raw === null || raw === void 0 ? void 0 : raw['s']) !== null && _b !== void 0 ? _b : 0, headers: (_c = raw === null || raw === void 0 ? void 0 : raw['h']) !== null && _c !== void 0 ? _c : {}, timeout: raw === null || raw === void 0 ? void 0 : raw['to'] }, (responseFormat === 'utf8'
@@ -207,12 +207,17 @@ class EditorClient {
         const action = this.getUniqueActionName();
         this.registerAction(action, async (rawMsg) => {
             var _a;
-            const msg = (0, registerunfurlmessage_1.deserializeRegisterUnfurlMessage)(rawMsg);
+            const msg = (0, unfurleventmessage_1.deserializeUnfurlEventMessage)(rawMsg);
             switch (msg.unfurlCallbackType) {
                 case unfurlcallbacks_1.UnfurlCallbackType.Unfurl: {
-                    const result = await callbacks.unfurlCallback(msg.url);
-                    if (result && !(0, unfurlrefresherrortype_1.unfurlRefreshErrorTypeValidator)(result)) {
-                        return (0, unfurldetails_1.serializeUnfurlDetails)(result);
+                    try {
+                        const result = await callbacks.unfurlCallback(msg.url);
+                        if (result && !(0, unfurlrefresherrortype_1.unfurlRefreshErrorTypeValidator)(result)) {
+                            return (0, unfurldetails_1.serializeUnfurlDetails)(result);
+                        }
+                    }
+                    catch (err) {
+                        return unfurlrefresherrortype_1.UnfurlRefreshErrorType.GenericFailure;
                     }
                     break;
                 }

package/sdk/index.d.ts

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

package/sdk/index.js

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

package/sdk/message/unfurleventmessage.d.ts

@@ -0,0 +1,24 @@
+import { JsonObject } from '../core/jsonserializable';
+import { UnfurlCallbackType } from '../core/unfurl/unfurlcallbacks';
+/** @ignore */
+export interface UnfurlEventMessage {
+    /** @ignore */
+    id: string;
+    /** @ignore */
+    url: string;
+    /** @ignore */
+    unfurlCallbackType: UnfurlCallbackType;
+    /** @ignore */
+    blockId?: string;
+}
+/** @ignore */
+export interface SerializedUnfurlEventMessage extends JsonObject {
+    'id': string;
+    'u': string;
+    't': UnfurlCallbackType;
+    'b'?: string;
+}
+/** @ignore */
+export declare function deserializeUnfurlEventMessage(raw: SerializedUnfurlEventMessage): UnfurlEventMessage;
+/** @ignore */
+export declare function serializeUnfurlEventMessage(concrete: UnfurlEventMessage): SerializedUnfurlEventMessage;

package/sdk/message/unfurleventmessage.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeUnfurlEventMessage = exports.deserializeUnfurlEventMessage = void 0;
+/** @ignore */
+function deserializeUnfurlEventMessage(raw) {
+    return {
+        id: raw['id'],
+        url: raw['u'],
+        unfurlCallbackType: raw['t'],
+        blockId: raw['b'],
+    };
+}
+exports.deserializeUnfurlEventMessage = deserializeUnfurlEventMessage;
+/** @ignore */
+function serializeUnfurlEventMessage(concrete) {
+    return {
+        'id': concrete.id,
+        'u': concrete.url,
+        't': concrete.unfurlCallbackType,
+        'b': concrete.blockId,
+    };
+}
+exports.serializeUnfurlEventMessage = serializeUnfurlEventMessage;

package/sdk/message/registerunfurlmessage.d.ts

@@ -1,32 +0,0 @@
-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 */
-    blockId?: string;
-}
-/** @ignore */
-export interface SerializedRegisterUnfurlMessage extends JsonObject {
-    'id': string;
-    'u': string;
-    't': UnfurlCallbackType;
-    'b'?: string;
-}
-/** @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;
-    b: (x: unknown) => x is string | undefined;
-}>;
-/** @ignore */
-export declare function deserializeRegisterUnfurlMessage(raw: SerializedRegisterUnfurlMessage): RegisterUnfurlMessage;
-/** @ignore */
-export declare function serializeRegisterUnfurlMessage(concrete: RegisterUnfurlMessage): SerializedRegisterUnfurlMessage;

package/sdk/message/registerunfurlmessage.js

@@ -1,33 +0,0 @@
-"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),
-    'b': (0, validators_1.option)(checks_1.isString),
-});
-/** @ignore */
-function deserializeRegisterUnfurlMessage(raw) {
-    return {
-        id: raw['id'],
-        url: raw['u'],
-        unfurlCallbackType: raw['t'],
-        blockId: raw['b'],
-    };
-}
-exports.deserializeRegisterUnfurlMessage = deserializeRegisterUnfurlMessage;
-/** @ignore */
-function serializeRegisterUnfurlMessage(concrete) {
-    return {
-        'id': concrete.id,
-        'u': concrete.url,
-        't': concrete.unfurlCallbackType,
-        'b': concrete.blockId,
-    };
-}
-exports.serializeRegisterUnfurlMessage = serializeRegisterUnfurlMessage;