@imbricate/core 3.19.0 → 3.20.0

package/document/property/triage.d.ts

@@ -3,6 +3,6 @@
  * @namespace Document_Property
  * @description Triage
  */
-import { DocumentProperties } from "../property";
+import { ImbricatePropertyRecord } from "../../property/map";
 import { ImbricateDocumentPropertyTriageManager } from "./triage-manager";
-export declare const triageImbricateDocumentProperties: <Result>(properties: DocumentProperties) => ImbricateDocumentPropertyTriageManager<Result>;
+export declare const triageImbricateDocumentProperties: <Result>(properties: ImbricatePropertyRecord) => ImbricateDocumentPropertyTriageManager<Result>;

package/error/property/feature-not-supported.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @author WMXPY
+ * @namespace Error
+ * @description Property Feature Not Supported
+ */
+import { IMBRICATE_PROPERTY_FEATURE } from "../../property/feature";
+import { PropertyError } from "./property-error";
+export declare class PropertyFeatureNotSupportedError extends PropertyError {
+    static withFeature(feature: IMBRICATE_PROPERTY_FEATURE): PropertyFeatureNotSupportedError;
+    static readonly TYPE: string;
+    protected constructor(message: string, reason?: any);
+}

package/error/property/feature-not-supported.js

@@ -0,0 +1,20 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Error
+ * @description Property Feature Not Supported
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropertyFeatureNotSupportedError = void 0;
+const property_error_1 = require("./property-error");
+class PropertyFeatureNotSupportedError extends property_error_1.PropertyError {
+    static withFeature(feature) {
+        return new PropertyFeatureNotSupportedError(`Feature ${feature} is not supported`, feature);
+    }
+    constructor(message, reason) {
+        super(message, PropertyFeatureNotSupportedError.TYPE, reason);
+        Object.setPrototypeOf(this, PropertyFeatureNotSupportedError.prototype);
+    }
+}
+exports.PropertyFeatureNotSupportedError = PropertyFeatureNotSupportedError;
+PropertyFeatureNotSupportedError.TYPE = "IMBRICATE_PROPERTY_FEATURE_NOT_SUPPORTED";

package/error/property/property-error.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @author WMXPY
+ * @namespace Error
+ * @description Property Error
+ */
+import { ImbricateError } from "../imbricate-error";
+export declare class PropertyError extends ImbricateError {
+    protected constructor(message: string, type: string, reason?: any);
+}

package/error/property/property-error.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Error
+ * @description Property Error
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropertyError = void 0;
+const imbricate_error_1 = require("../imbricate-error");
+class PropertyError extends imbricate_error_1.ImbricateError {
+    constructor(message, type, reason) {
+        super(message, type, reason);
+        Object.setPrototypeOf(this, PropertyError.prototype);
+    }
+}
+exports.PropertyError = PropertyError;

package/index.d.ts

@@ -10,6 +10,7 @@ export * from "./document/export";
 export * from "./error/export";
 export * from "./loader/export";
 export * from "./origin/export";
+export * from "./property/export";
 export * from "./static-manager/export";
 export * from "./static/export";
 export * from "./text-manager/export";

package/index.js

@@ -26,6 +26,7 @@ __exportStar(require("./document/export"), exports);
 __exportStar(require("./error/export"), exports);
 __exportStar(require("./loader/export"), exports);
 __exportStar(require("./origin/export"), exports);
+__exportStar(require("./property/export"), exports);
 __exportStar(require("./static-manager/export"), exports);
 __exportStar(require("./static/export"), exports);
 __exportStar(require("./text-manager/export"), exports);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@imbricate/core",
   "main": "index.js",
-  "version": "3.19.0",
+  "version": "3.20.0",
   "description": "Imbricate Core, Notebook for Engineers",
   "repository": {
     "type": "git",

package/property/base-class/full-feature-with-action.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @author WMXPY
+ * @namespace Property
+ * @description Full Feature
+ */
+import { ImbricateCommonQueryOriginActionsOutcome, ImbricateCommonQueryOriginActionsQuery, ImbricateOriginActionInput, ImbricateOriginActionOutcome } from "../../common/action";
+import { ImbricatePropertyKey } from "../definition";
+import { IMBRICATE_PROPERTY_FEATURE } from "../feature";
+import { IImbricateProperty } from "../interface";
+import { IMBRICATE_PROPERTY_TYPE, ImbricatePropertyValueObject } from "../type";
+export declare abstract class ImbricatePropertyFullFeatureWithActionBase<T extends IMBRICATE_PROPERTY_TYPE> implements IImbricateProperty<T> {
+    abstract readonly propertyKey: ImbricatePropertyKey;
+    abstract readonly propertyType: T;
+    abstract readonly propertyValue: ImbricatePropertyValueObject<T>;
+    readonly supportedFeatures: IMBRICATE_PROPERTY_FEATURE[];
+    abstract queryOriginActions(query: ImbricateCommonQueryOriginActionsQuery): PromiseLike<ImbricateCommonQueryOriginActionsOutcome>;
+    abstract executeOriginAction(input: ImbricateOriginActionInput): PromiseLike<ImbricateOriginActionOutcome>;
+}

package/property/base-class/full-feature-with-action.js

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Property
+ * @description Full Feature
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImbricatePropertyFullFeatureWithActionBase = void 0;
+const feature_1 = require("../feature");
+class ImbricatePropertyFullFeatureWithActionBase {
+    constructor() {
+        this.supportedFeatures = [
+            feature_1.IMBRICATE_PROPERTY_FEATURE.PROPERTY_GET_ORIGIN_ACTIONS,
+            feature_1.IMBRICATE_PROPERTY_FEATURE.PROPERTY_EXECUTE_ORIGIN_ACTION,
+        ];
+    }
+}
+exports.ImbricatePropertyFullFeatureWithActionBase = ImbricatePropertyFullFeatureWithActionBase;

package/property/base-class/full-feature.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @author WMXPY
+ * @namespace Property
+ * @description Full Feature
+ */
+import { ImbricateCommonQueryOriginActionsOutcome, ImbricateCommonQueryOriginActionsQuery, ImbricateOriginActionInput, ImbricateOriginActionOutcome } from "../../common/action";
+import { IMBRICATE_PROPERTY_FEATURE } from "../feature";
+import { IImbricateProperty } from "../interface";
+import { IMBRICATE_PROPERTY_TYPE } from "../type";
+import { ImbricatePropertyFullFeatureWithActionBase } from "./full-feature-with-action";
+export declare abstract class ImbricatePropertyFullFeatureBase<T extends IMBRICATE_PROPERTY_TYPE> extends ImbricatePropertyFullFeatureWithActionBase<T> implements IImbricateProperty<T> {
+    readonly supportedFeatures: IMBRICATE_PROPERTY_FEATURE[];
+    queryOriginActions(_query: ImbricateCommonQueryOriginActionsQuery): PromiseLike<ImbricateCommonQueryOriginActionsOutcome>;
+    executeOriginAction(_input: ImbricateOriginActionInput): PromiseLike<ImbricateOriginActionOutcome>;
+}

package/property/base-class/full-feature.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Property
+ * @description Full Feature
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImbricatePropertyFullFeatureBase = void 0;
+const feature_not_supported_1 = require("../../error/property/feature-not-supported");
+const feature_1 = require("../feature");
+const full_feature_with_action_1 = require("./full-feature-with-action");
+class ImbricatePropertyFullFeatureBase extends full_feature_with_action_1.ImbricatePropertyFullFeatureWithActionBase {
+    constructor() {
+        super(...arguments);
+        this.supportedFeatures = [];
+    }
+    queryOriginActions(_query) {
+        throw feature_not_supported_1.PropertyFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_PROPERTY_FEATURE.PROPERTY_GET_ORIGIN_ACTIONS);
+    }
+    executeOriginAction(_input) {
+        throw feature_not_supported_1.PropertyFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_PROPERTY_FEATURE.PROPERTY_EXECUTE_ORIGIN_ACTION);
+    }
+}
+exports.ImbricatePropertyFullFeatureBase = ImbricatePropertyFullFeatureBase;

package/property/definition.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @author WMXPY
+ * @namespace Property
+ * @description Definition
+ */
+/**
+ * Imbricate property key, which should match schema properties unique identifier
+ */
+export type ImbricatePropertyKey = string;

package/property/definition.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Property
+ * @description Definition
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/property/export.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @author WMXPY
+ * @namespace Property
+ * @description Export
+ */
+export * from "./base-class/full-feature";
+export * from "./base-class/full-feature-with-action";
+export * from "./definition";
+export * from "./feature";
+export * from "./interface";
+export * from "./map";
+export * from "./type";
+export * from "./validate";

package/property/export.js

@@ -0,0 +1,29 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Property
+ * @description Export
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./base-class/full-feature"), exports);
+__exportStar(require("./base-class/full-feature-with-action"), exports);
+__exportStar(require("./definition"), exports);
+__exportStar(require("./feature"), exports);
+__exportStar(require("./interface"), exports);
+__exportStar(require("./map"), exports);
+__exportStar(require("./type"), exports);
+__exportStar(require("./validate"), exports);

package/property/feature.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @author WMXPY
+ * @namespace Property
+ * @description Feature
+ */
+export declare enum IMBRICATE_PROPERTY_FEATURE {
+    PROPERTY_GET_ORIGIN_ACTIONS = "PROPERTY_GET_ORIGIN_ACTIONS",
+    PROPERTY_EXECUTE_ORIGIN_ACTION = "PROPERTY_EXECUTE_ORIGIN_ACTION"
+}
+export declare const checkImbricatePropertyFeatureSupported: (features: IMBRICATE_PROPERTY_FEATURE[], feature: IMBRICATE_PROPERTY_FEATURE) => boolean;

package/property/feature.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Property
+ * @description Feature
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkImbricatePropertyFeatureSupported = exports.IMBRICATE_PROPERTY_FEATURE = void 0;
+var IMBRICATE_PROPERTY_FEATURE;
+(function (IMBRICATE_PROPERTY_FEATURE) {
+    IMBRICATE_PROPERTY_FEATURE["PROPERTY_GET_ORIGIN_ACTIONS"] = "PROPERTY_GET_ORIGIN_ACTIONS";
+    IMBRICATE_PROPERTY_FEATURE["PROPERTY_EXECUTE_ORIGIN_ACTION"] = "PROPERTY_EXECUTE_ORIGIN_ACTION";
+})(IMBRICATE_PROPERTY_FEATURE || (exports.IMBRICATE_PROPERTY_FEATURE = IMBRICATE_PROPERTY_FEATURE = {}));
+const checkImbricatePropertyFeatureSupported = (features, feature) => {
+    return features.includes(feature);
+};
+exports.checkImbricatePropertyFeatureSupported = checkImbricatePropertyFeatureSupported;

package/property/interface.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @author WMXPY
+ * @namespace Property
+ * @description Interface
+ */
+import { ImbricateCommonQueryOriginActionsOutcome, ImbricateCommonQueryOriginActionsQuery, ImbricateOriginActionInput, ImbricateOriginActionOutcome } from "../common/action";
+import { ImbricatePropertyKey } from "./definition";
+import { IMBRICATE_PROPERTY_FEATURE } from "./feature";
+import { IMBRICATE_PROPERTY_TYPE, ImbricatePropertyValueObject } from "./type";
+export interface IImbricateProperty<T extends IMBRICATE_PROPERTY_TYPE> {
+    /**
+     * Property key, reference to the property key from documents
+     */
+    readonly propertyKey: ImbricatePropertyKey;
+    /**
+     * Property type
+     */
+    readonly propertyType: T;
+    /**
+     * Property value
+     */
+    readonly propertyValue: ImbricatePropertyValueObject<T>;
+    /**
+     * Supported features of the property
+     */
+    readonly supportedFeatures: IMBRICATE_PROPERTY_FEATURE[];
+    /**
+     * Query the property actions
+     *
+     * @param query the query of the property actions
+     *
+     * @returns the property actions
+     *  Symbol: S_Common_QueryOriginActions_Stale - if the property actions are stale
+     *  Symbol: S_Common_QueryOriginActions_Unknown - if the property actions are unknown
+     */
+    queryOriginActions(query: ImbricateCommonQueryOriginActionsQuery): PromiseLike<ImbricateCommonQueryOriginActionsOutcome>;
+    /**
+     * Execute the property action
+     *
+     * @param input the input of the action
+     *
+     * @returns the result of the action
+     */
+    executeOriginAction(input: ImbricateOriginActionInput): PromiseLike<ImbricateOriginActionOutcome>;
+}

package/property/interface.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Property
+ * @description Interface
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/property/map.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @author WMXPY
+ * @namespace Property
+ * @description Map
+ */
+import { ImbricatePropertyKey } from "./definition";
+import { IImbricateProperty } from "./interface";
+import { IMBRICATE_PROPERTY_TYPE } from "./type";
+export type ImbricatePropertyRecord = Record<ImbricatePropertyKey, IImbricateProperty<IMBRICATE_PROPERTY_TYPE>>;

package/property/map.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Property
+ * @description Map
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/{document/property.d.ts → property/type.d.ts}

@@ -1,10 +1,10 @@
 /**
  * @author WMXPY
- * @namespace Document
- * @description Property
+ * @namespace Property
+ * @description Type
  */
 /**
- * Document properties
+ * Property type
  */
 export declare enum IMBRICATE_PROPERTY_TYPE {
     /**
@@ -48,24 +48,9 @@ export declare enum IMBRICATE_PROPERTY_TYPE {
      */
     REFERENCE = "REFERENCE"
 }
-/**
- * Document properties
- *
- * Key - Property key, which should match schema properties unique identifier
- * Value - Property value, which should match schema properties type
- */
-export type DocumentProperties = Record<DocumentPropertyKey, DocumentPropertyValue<IMBRICATE_PROPERTY_TYPE>>;
-/**
- * Document property key, which should match schema properties unique identifier
- */
-export type DocumentPropertyKey = string;
-export type DocumentPropertyValue<T extends IMBRICATE_PROPERTY_TYPE> = {
-    readonly type: T;
-    readonly value: DocumentPropertyValueObject<T>;
-};
-export type DocumentPropertyValueObjectReference = {
+export type ImbricatePropertyValueObjectReference = {
     readonly originUniqueIdentifier: string;
     readonly databaseUniqueIdentifier: string;
     readonly documentUniqueIdentifier: string;
 };
-export type DocumentPropertyValueObject<T extends IMBRICATE_PROPERTY_TYPE> = T extends IMBRICATE_PROPERTY_TYPE.BOOLEAN ? boolean : T extends IMBRICATE_PROPERTY_TYPE.STRING ? string : T extends IMBRICATE_PROPERTY_TYPE.NUMBER ? number : T extends IMBRICATE_PROPERTY_TYPE.MARKDOWN ? string : T extends IMBRICATE_PROPERTY_TYPE.JSON ? string : T extends IMBRICATE_PROPERTY_TYPE.IMBRISCRIPT ? string : T extends IMBRICATE_PROPERTY_TYPE.DATE ? string : T extends IMBRICATE_PROPERTY_TYPE.LABEL ? string[] : T extends IMBRICATE_PROPERTY_TYPE.REFERENCE ? DocumentPropertyValueObjectReference[] : never;
+export type ImbricatePropertyValueObject<T extends IMBRICATE_PROPERTY_TYPE> = T extends IMBRICATE_PROPERTY_TYPE.BOOLEAN ? boolean : T extends IMBRICATE_PROPERTY_TYPE.STRING ? string : T extends IMBRICATE_PROPERTY_TYPE.NUMBER ? number : T extends IMBRICATE_PROPERTY_TYPE.MARKDOWN ? string : T extends IMBRICATE_PROPERTY_TYPE.JSON ? string : T extends IMBRICATE_PROPERTY_TYPE.IMBRISCRIPT ? string : T extends IMBRICATE_PROPERTY_TYPE.DATE ? string : T extends IMBRICATE_PROPERTY_TYPE.LABEL ? string[] : T extends IMBRICATE_PROPERTY_TYPE.REFERENCE ? ImbricatePropertyValueObjectReference[] : never;

package/{document/property.js → property/type.js}

@@ -1,13 +1,13 @@
 "use strict";
 /**
  * @author WMXPY
- * @namespace Document
- * @description Property
+ * @namespace Property
+ * @description Type
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IMBRICATE_PROPERTY_TYPE = void 0;
 /**
- * Document properties
+ * Property type
  */
 var IMBRICATE_PROPERTY_TYPE;
 (function (IMBRICATE_PROPERTY_TYPE) {

package/{document → property}/validate.d.ts

@@ -1,10 +1,10 @@
 /**
  * @author WMXPY
- * @namespace Document
+ * @namespace Property
  * @description Validate
  */
 import { ImbricateDatabaseSchema } from "../database/schema";
-import { DocumentProperties } from "./property";
+import { ImbricatePropertyRecord } from "./map";
 /**
  * Validate properties with schema
  *
@@ -15,4 +15,4 @@ import { DocumentProperties } from "./property";
  * @returns a string error message if validation failed
  *        null if validation passed
  */
-export declare const validateImbricateProperties: (properties: DocumentProperties, schema: ImbricateDatabaseSchema, allowExtraProperties?: boolean) => string | null;
+export declare const validateImbricateProperties: (properties: ImbricatePropertyRecord, schema: ImbricateDatabaseSchema, allowExtraProperties?: boolean) => string | null;

package/{document → property}/validate.js

@@ -1,12 +1,12 @@
 "use strict";
 /**
  * @author WMXPY
- * @namespace Document
+ * @namespace Property
  * @description Validate
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateImbricateProperties = void 0;
-const property_1 = require("./property");
+const type_1 = require("./type");
 /**
  * Validate properties with schema
  *
@@ -23,86 +23,86 @@ const validateImbricateProperties = (properties, schema, allowExtraProperties =
     }
     const keys = Object.keys(properties);
     for (const key of keys) {
-        const property = schema.properties.find((each) => {
+        const schemaProperty = schema.properties.find((each) => {
             return each.propertyIdentifier === key;
         });
-        if (!property) {
+        if (!schemaProperty) {
             if (allowExtraProperties) {
                 continue;
             }
             return `Property ${key} not found in schema`;
         }
-        const value = properties[key];
-        if (typeof value.type !== "string") {
+        const property = properties[key];
+        if (typeof property.propertyType !== "string") {
             return `Property ${key} type must be a string`;
         }
-        if (value.type !== property.propertyType) {
-            return `Property ${key} type must be ${property.propertyType}, but got ${value.type}`;
+        if (property.propertyType !== property.propertyType) {
+            return `Property ${key} type must be ${property.propertyType}, but got ${property.propertyType}`;
         }
         // IMBRICATE_PROPERTY_TYPE SWITCH
-        switch (value.type) {
-            case property_1.IMBRICATE_PROPERTY_TYPE.BOOLEAN: {
-                if (typeof value.value !== "boolean") {
+        switch (property.propertyType) {
+            case type_1.IMBRICATE_PROPERTY_TYPE.BOOLEAN: {
+                if (typeof property.propertyValue !== "boolean") {
                     return `Property ${key} value must be a boolean`;
                 }
                 break;
             }
-            case property_1.IMBRICATE_PROPERTY_TYPE.STRING: {
-                if (typeof value.value !== "string") {
+            case type_1.IMBRICATE_PROPERTY_TYPE.STRING: {
+                if (typeof property.propertyValue !== "string") {
                     return `Property ${key} value must be a string`;
                 }
                 break;
             }
-            case property_1.IMBRICATE_PROPERTY_TYPE.NUMBER: {
-                if (typeof value.value !== "number") {
+            case type_1.IMBRICATE_PROPERTY_TYPE.NUMBER: {
+                if (typeof property.propertyValue !== "number") {
                     return `Property ${key} value must be a number`;
                 }
                 break;
             }
-            case property_1.IMBRICATE_PROPERTY_TYPE.MARKDOWN: {
-                if (typeof value.value !== "string") {
+            case type_1.IMBRICATE_PROPERTY_TYPE.MARKDOWN: {
+                if (typeof property.propertyValue !== "string") {
                     return `Property ${key} value must be a string`;
                 }
                 break;
             }
-            case property_1.IMBRICATE_PROPERTY_TYPE.JSON: {
-                if (typeof value.value !== "string") {
+            case type_1.IMBRICATE_PROPERTY_TYPE.JSON: {
+                if (typeof property.propertyValue !== "string") {
                     return `Property ${key} value must be a string`;
                 }
                 break;
             }
-            case property_1.IMBRICATE_PROPERTY_TYPE.IMBRISCRIPT: {
-                if (typeof value.value !== "string") {
+            case type_1.IMBRICATE_PROPERTY_TYPE.IMBRISCRIPT: {
+                if (typeof property.propertyValue !== "string") {
                     return `Property ${key} value must be a string`;
                 }
                 break;
             }
-            case property_1.IMBRICATE_PROPERTY_TYPE.DATE: {
-                if (typeof value.value !== "string") {
+            case type_1.IMBRICATE_PROPERTY_TYPE.DATE: {
+                if (typeof property.propertyValue !== "string") {
                     return `Property ${key} value must be a string of date in ISO format`;
                 }
-                const date = new Date(value.value);
+                const date = new Date(property.propertyValue);
                 if (isNaN(date.getTime())) {
                     return `Property ${key} value must be a string of date in ISO format`;
                 }
                 break;
             }
-            case property_1.IMBRICATE_PROPERTY_TYPE.LABEL: {
-                if (!Array.isArray(value.value)) {
+            case type_1.IMBRICATE_PROPERTY_TYPE.LABEL: {
+                if (!Array.isArray(property.propertyValue)) {
                     return `Property ${key} value must be an array of string`;
                 }
-                for (const label of value.value) {
+                for (const label of property.propertyValue) {
                     if (typeof label !== "string") {
                         return `Property ${key} label must be a string`;
                     }
                 }
                 break;
             }
-            case property_1.IMBRICATE_PROPERTY_TYPE.REFERENCE: {
-                if (!Array.isArray(value.value)) {
+            case type_1.IMBRICATE_PROPERTY_TYPE.REFERENCE: {
+                if (!Array.isArray(property.propertyValue)) {
                     return `Property ${key} value must be an array of string`;
                 }
-                for (const reference of value.value) {
+                for (const reference of property.propertyValue) {
                     if (typeof reference !== "object") {
                         return `Property ${key} reference must be an object`;
                     }
@@ -118,6 +118,9 @@ const validateImbricateProperties = (properties, schema, allowExtraProperties =
                 }
                 break;
             }
+            default: {
+                return `Property ${key} type ${property.propertyType} is not supported`;
+            }
         }
     }
     return null;