@imbricate/core 3.11.0 → 3.14.0

package/document/base-class/exclude-annotation.js

@@ -0,0 +1,29 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Document
+ * @description Exclude Annotation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImbricateDocumentExcludeAnnotationBase = void 0;
+const feature_not_supported_1 = require("../../error/document/feature-not-supported");
+const feature_1 = require("../feature");
+const full_feature_1 = require("./full-feature");
+class ImbricateDocumentExcludeAnnotationBase extends full_feature_1.ImbricateDocumentFullFeatureBase {
+    constructor() {
+        super(...arguments);
+        this.annotations = {};
+        this.supportedFeatures = [
+            feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_PUT_PROPERTY,
+            feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_PUT_EDIT_RECORD,
+            feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_GET_EDIT_RECORD,
+        ];
+    }
+    putAnnotation(_namespace, _identifier, _value, _auditOptions) {
+        throw feature_not_supported_1.ImbricateDocumentFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_PUT_ANNOTATION);
+    }
+    deleteAnnotation(_namespace, _identifier, _auditOptions) {
+        throw feature_not_supported_1.ImbricateDocumentFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_DELETE_ANNOTATION);
+    }
+}
+exports.ImbricateDocumentExcludeAnnotationBase = ImbricateDocumentExcludeAnnotationBase;

package/document/base-class/exclude-edit-records.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @author WMXPY
+ * @namespace Document
+ * @description Exclude Edit Records
+ */
+import { DocumentEditRecord } from "../definition";
+import { IMBRICATE_DOCUMENT_FEATURE } from "../feature";
+import { IImbricateDocument } from "../interface";
+import { ImbricateDocumentAddEditRecordsOutcome, ImbricateDocumentGetEditRecordsOutcome } from "../outcome";
+import { ImbricateDocumentFullFeatureBase } from "./full-feature";
+export declare abstract class ImbricateDocumentExcludeEditRecordsBase extends ImbricateDocumentFullFeatureBase implements IImbricateDocument {
+    readonly supportedFeatures: IMBRICATE_DOCUMENT_FEATURE[];
+    addEditRecords(_records: DocumentEditRecord[]): Promise<ImbricateDocumentAddEditRecordsOutcome>;
+    getEditRecords(): Promise<ImbricateDocumentGetEditRecordsOutcome>;
+}

package/document/base-class/exclude-edit-records.js

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Document
+ * @description Exclude Edit Records
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImbricateDocumentExcludeEditRecordsBase = void 0;
+const feature_not_supported_1 = require("../../error/document/feature-not-supported");
+const feature_1 = require("../feature");
+const full_feature_1 = require("./full-feature");
+class ImbricateDocumentExcludeEditRecordsBase extends full_feature_1.ImbricateDocumentFullFeatureBase {
+    constructor() {
+        super(...arguments);
+        this.supportedFeatures = [
+            feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_PUT_PROPERTY,
+            feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_PUT_ANNOTATION,
+            feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_DELETE_ANNOTATION,
+        ];
+    }
+    addEditRecords(_records) {
+        throw feature_not_supported_1.ImbricateDocumentFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_PUT_EDIT_RECORD);
+    }
+    getEditRecords() {
+        throw feature_not_supported_1.ImbricateDocumentFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_GET_EDIT_RECORD);
+    }
+}
+exports.ImbricateDocumentExcludeEditRecordsBase = ImbricateDocumentExcludeEditRecordsBase;

package/document/base-class/full-feature-readonly.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @author WMXPY
+ * @namespace Document
+ * @description Full Feature Readonly
+ */
+import { DocumentAnnotationValue, DocumentEditRecord, ImbricateDocumentAuditOptions } from "../definition";
+import { IMBRICATE_DOCUMENT_FEATURE } from "../feature";
+import { IImbricateDocument } from "../interface";
+import { ImbricateDocumentAddEditRecordsOutcome, ImbricateDocumentDeleteAnnotationOutcome, ImbricateDocumentPutAnnotationOutcome, ImbricateDocumentPutPropertyOutcome } from "../outcome";
+import { DocumentProperties, DocumentPropertyKey, DocumentPropertyValue, IMBRICATE_PROPERTY_TYPE } from "../property";
+import { ImbricateDocumentFullFeatureBase } from "./full-feature";
+export declare abstract class ImbricateDocumentFullFeatureReadonlyBase extends ImbricateDocumentFullFeatureBase implements IImbricateDocument {
+    readonly supportedFeatures: IMBRICATE_DOCUMENT_FEATURE[];
+    putProperty(_key: DocumentPropertyKey, _value: DocumentPropertyValue<IMBRICATE_PROPERTY_TYPE>, _auditOptions?: ImbricateDocumentAuditOptions): Promise<ImbricateDocumentPutPropertyOutcome>;
+    putProperties(_properties: DocumentProperties, _auditOptions?: ImbricateDocumentAuditOptions): Promise<ImbricateDocumentPutPropertyOutcome>;
+    putAnnotation(_namespace: string, _identifier: string, _value: DocumentAnnotationValue, _auditOptions?: ImbricateDocumentAuditOptions): Promise<ImbricateDocumentPutAnnotationOutcome>;
+    deleteAnnotation(_namespace: string, _identifier: string, _auditOptions?: ImbricateDocumentAuditOptions): Promise<ImbricateDocumentDeleteAnnotationOutcome>;
+    addEditRecords(_records: DocumentEditRecord[]): Promise<ImbricateDocumentAddEditRecordsOutcome>;
+}

package/document/base-class/full-feature-readonly.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Document
+ * @description Full Feature Readonly
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImbricateDocumentFullFeatureReadonlyBase = void 0;
+const feature_not_supported_1 = require("../../error/document/feature-not-supported");
+const feature_1 = require("../feature");
+const full_feature_1 = require("./full-feature");
+class ImbricateDocumentFullFeatureReadonlyBase extends full_feature_1.ImbricateDocumentFullFeatureBase {
+    constructor() {
+        super(...arguments);
+        this.supportedFeatures = [
+            feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_GET_EDIT_RECORD,
+        ];
+    }
+    putProperty(_key, _value, _auditOptions) {
+        throw feature_not_supported_1.ImbricateDocumentFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_PUT_PROPERTY);
+    }
+    putProperties(_properties, _auditOptions) {
+        throw feature_not_supported_1.ImbricateDocumentFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_PUT_PROPERTY);
+    }
+    putAnnotation(_namespace, _identifier, _value, _auditOptions) {
+        throw feature_not_supported_1.ImbricateDocumentFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_PUT_ANNOTATION);
+    }
+    deleteAnnotation(_namespace, _identifier, _auditOptions) {
+        throw feature_not_supported_1.ImbricateDocumentFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_DELETE_ANNOTATION);
+    }
+    addEditRecords(_records) {
+        throw feature_not_supported_1.ImbricateDocumentFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_PUT_EDIT_RECORD);
+    }
+}
+exports.ImbricateDocumentFullFeatureReadonlyBase = ImbricateDocumentFullFeatureReadonlyBase;

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

@@ -0,0 +1,23 @@
+/**
+ * @author WMXPY
+ * @namespace Document
+ * @description Full Feature
+ */
+import { DocumentAnnotationValue, DocumentAnnotations, DocumentEditRecord, ImbricateDocumentAuditOptions } from "../definition";
+import { IMBRICATE_DOCUMENT_FEATURE } from "../feature";
+import { IImbricateDocument } from "../interface";
+import { ImbricateDocumentAddEditRecordsOutcome, ImbricateDocumentDeleteAnnotationOutcome, ImbricateDocumentGetEditRecordsOutcome, ImbricateDocumentPutAnnotationOutcome, ImbricateDocumentPutPropertyOutcome } from "../outcome";
+import { DocumentProperties, DocumentPropertyKey, DocumentPropertyValue, IMBRICATE_PROPERTY_TYPE } from "../property";
+export declare abstract class ImbricateDocumentFullFeatureBase implements IImbricateDocument {
+    abstract readonly uniqueIdentifier: string;
+    abstract readonly documentVersion: string;
+    abstract readonly properties: DocumentProperties;
+    abstract readonly annotations: DocumentAnnotations;
+    readonly supportedFeatures: IMBRICATE_DOCUMENT_FEATURE[];
+    abstract putProperty(key: DocumentPropertyKey, value: DocumentPropertyValue<IMBRICATE_PROPERTY_TYPE>, auditOptions?: ImbricateDocumentAuditOptions): Promise<ImbricateDocumentPutPropertyOutcome>;
+    abstract putProperties(properties: DocumentProperties, auditOptions?: ImbricateDocumentAuditOptions): Promise<ImbricateDocumentPutPropertyOutcome>;
+    abstract putAnnotation(namespace: string, identifier: string, value: DocumentAnnotationValue, auditOptions?: ImbricateDocumentAuditOptions): Promise<ImbricateDocumentPutAnnotationOutcome>;
+    abstract deleteAnnotation(namespace: string, identifier: string, auditOptions?: ImbricateDocumentAuditOptions): Promise<ImbricateDocumentDeleteAnnotationOutcome>;
+    abstract addEditRecords(records: DocumentEditRecord[]): Promise<ImbricateDocumentAddEditRecordsOutcome>;
+    abstract getEditRecords(): Promise<ImbricateDocumentGetEditRecordsOutcome>;
+}

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

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Document
+ * @description Full Feature
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImbricateDocumentFullFeatureBase = void 0;
+const feature_1 = require("../feature");
+class ImbricateDocumentFullFeatureBase {
+    constructor() {
+        this.supportedFeatures = [
+            feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_PUT_PROPERTY,
+            feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_PUT_ANNOTATION,
+            feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_DELETE_ANNOTATION,
+            feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_PUT_EDIT_RECORD,
+            feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_GET_EDIT_RECORD,
+        ];
+    }
+}
+exports.ImbricateDocumentFullFeatureBase = ImbricateDocumentFullFeatureBase;

package/document/export.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @author WMXPY
+ * @namespace Document
+ * @description Export
+ */
+export * from "./base-class/essential";
+export * from "./base-class/essential-readonly";
+export * from "./base-class/exclude-annotation";
+export * from "./base-class/exclude-edit-records";
+export * from "./base-class/full-feature";
+export * from "./base-class/full-feature-readonly";
+export * from "./definition";
+export * from "./feature";
+export * from "./interface";
+export * from "./outcome";
+export * from "./property";
+export * from "./property/default-value";
+export * from "./property/definition";
+export * from "./property/primary";
+export * from "./property/triage";
+export * from "./property/triage-manager";
+export * from "./validate";

package/document/export.js

@@ -0,0 +1,38 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Document
+ * @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/essential"), exports);
+__exportStar(require("./base-class/essential-readonly"), exports);
+__exportStar(require("./base-class/exclude-annotation"), exports);
+__exportStar(require("./base-class/exclude-edit-records"), exports);
+__exportStar(require("./base-class/full-feature"), exports);
+__exportStar(require("./base-class/full-feature-readonly"), exports);
+__exportStar(require("./definition"), exports);
+__exportStar(require("./feature"), exports);
+__exportStar(require("./interface"), exports);
+__exportStar(require("./outcome"), exports);
+__exportStar(require("./property"), exports);
+__exportStar(require("./property/default-value"), exports);
+__exportStar(require("./property/definition"), exports);
+__exportStar(require("./property/primary"), exports);
+__exportStar(require("./property/triage"), exports);
+__exportStar(require("./property/triage-manager"), exports);
+__exportStar(require("./validate"), exports);

package/document/feature.d.ts

@@ -6,12 +6,8 @@
 export declare enum IMBRICATE_DOCUMENT_FEATURE {
     DOCUMENT_PUT_PROPERTY = "DOCUMENT_PUT_PROPERTY",
     DOCUMENT_PUT_ANNOTATION = "DOCUMENT_PUT_ANNOTATION",
-    DOCUMENT_REMOVE_ANNOTATION = "DOCUMENT_REMOVE_ANNOTATION",
+    DOCUMENT_DELETE_ANNOTATION = "DOCUMENT_DELETE_ANNOTATION",
     DOCUMENT_PUT_EDIT_RECORD = "DOCUMENT_PUT_EDIT_RECORD",
     DOCUMENT_GET_EDIT_RECORD = "DOCUMENT_GET_EDIT_RECORD"
 }
-export declare const fullSupportedDocumentFeatures: IMBRICATE_DOCUMENT_FEATURE[];
-export declare const annotationExcludedDocumentFeatures: IMBRICATE_DOCUMENT_FEATURE[];
-export declare const editRecordExcludedDocumentFeatures: IMBRICATE_DOCUMENT_FEATURE[];
-export declare const IMBRICATE_DOCUMENT_PRESET_FEATURES: Record<string, IMBRICATE_DOCUMENT_FEATURE[]>;
 export declare const checkImbricateDocumentFeatureSupported: (features: IMBRICATE_DOCUMENT_FEATURE[], feature: IMBRICATE_DOCUMENT_FEATURE) => boolean;

package/document/feature.js

@@ -5,37 +5,15 @@
  * @description Feature
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkImbricateDocumentFeatureSupported = exports.IMBRICATE_DOCUMENT_PRESET_FEATURES = exports.editRecordExcludedDocumentFeatures = exports.annotationExcludedDocumentFeatures = exports.fullSupportedDocumentFeatures = exports.IMBRICATE_DOCUMENT_FEATURE = void 0;
+exports.checkImbricateDocumentFeatureSupported = exports.IMBRICATE_DOCUMENT_FEATURE = void 0;
 var IMBRICATE_DOCUMENT_FEATURE;
 (function (IMBRICATE_DOCUMENT_FEATURE) {
     IMBRICATE_DOCUMENT_FEATURE["DOCUMENT_PUT_PROPERTY"] = "DOCUMENT_PUT_PROPERTY";
     IMBRICATE_DOCUMENT_FEATURE["DOCUMENT_PUT_ANNOTATION"] = "DOCUMENT_PUT_ANNOTATION";
-    IMBRICATE_DOCUMENT_FEATURE["DOCUMENT_REMOVE_ANNOTATION"] = "DOCUMENT_REMOVE_ANNOTATION";
+    IMBRICATE_DOCUMENT_FEATURE["DOCUMENT_DELETE_ANNOTATION"] = "DOCUMENT_DELETE_ANNOTATION";
     IMBRICATE_DOCUMENT_FEATURE["DOCUMENT_PUT_EDIT_RECORD"] = "DOCUMENT_PUT_EDIT_RECORD";
     IMBRICATE_DOCUMENT_FEATURE["DOCUMENT_GET_EDIT_RECORD"] = "DOCUMENT_GET_EDIT_RECORD";
 })(IMBRICATE_DOCUMENT_FEATURE || (exports.IMBRICATE_DOCUMENT_FEATURE = IMBRICATE_DOCUMENT_FEATURE = {}));
-exports.fullSupportedDocumentFeatures = [
-    IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_PUT_PROPERTY,
-    IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_PUT_ANNOTATION,
-    IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_REMOVE_ANNOTATION,
-    IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_PUT_EDIT_RECORD,
-    IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_GET_EDIT_RECORD,
-];
-exports.annotationExcludedDocumentFeatures = [
-    IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_PUT_PROPERTY,
-    IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_PUT_EDIT_RECORD,
-    IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_GET_EDIT_RECORD,
-];
-exports.editRecordExcludedDocumentFeatures = [
-    IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_PUT_PROPERTY,
-    IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_PUT_ANNOTATION,
-    IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_REMOVE_ANNOTATION,
-];
-exports.IMBRICATE_DOCUMENT_PRESET_FEATURES = {
-    FULL_SUPPORTED_FEATURES: exports.fullSupportedDocumentFeatures,
-    ANNOTATION_EXCLUDED_FEATURES: exports.annotationExcludedDocumentFeatures,
-    EDIT_RECORD_EXCLUDED_FEATURES: exports.editRecordExcludedDocumentFeatures,
-};
 const checkImbricateDocumentFeatureSupported = (features, feature) => {
     return features.includes(feature);
 };

package/document/interface.d.ts

@@ -5,6 +5,7 @@
  */
 import { DocumentAnnotationValue, DocumentAnnotations, DocumentEditRecord, ImbricateDocumentAuditOptions } from "./definition";
 import { IMBRICATE_DOCUMENT_FEATURE } from "./feature";
+import { ImbricateDocumentAddEditRecordsOutcome, ImbricateDocumentDeleteAnnotationOutcome, ImbricateDocumentGetEditRecordsOutcome, ImbricateDocumentPutAnnotationOutcome, ImbricateDocumentPutPropertyOutcome } from "./outcome";
 import { DocumentProperties, DocumentPropertyKey, DocumentPropertyValue, IMBRICATE_PROPERTY_TYPE } from "./property";
 export interface IImbricateDocument {
     /**
@@ -14,7 +15,7 @@ export interface IImbricateDocument {
     /**
      * Version of the document draft
      */
-    readonly documentVersion: number;
+    readonly documentVersion: string;
     /**
      * Properties of the document
      */
@@ -36,11 +37,10 @@ export interface IImbricateDocument {
      * @param value value of the property
      * @param auditOptions audit options of the document
      *
-     * @returns a promise of the edit records of the document
-     *  Note: the edit records will not be added to the document if `noEditRecord` is true,
-     *  Call `addEditRecords` to add the edit records manually.
+     * @returns a promise of the outcome of the put property
+     *  Symbol: S_Document_PutProperty_InvalidKey - if the key is invalid
      */
-    putProperty(key: DocumentPropertyKey, value: DocumentPropertyValue<IMBRICATE_PROPERTY_TYPE>, auditOptions?: ImbricateDocumentAuditOptions): PromiseLike<DocumentEditRecord[]>;
+    putProperty(key: DocumentPropertyKey, value: DocumentPropertyValue<IMBRICATE_PROPERTY_TYPE>, auditOptions?: ImbricateDocumentAuditOptions): PromiseLike<ImbricateDocumentPutPropertyOutcome>;
     /**
      * Put and replace all properties of the document, optional
      *
@@ -49,11 +49,10 @@ export interface IImbricateDocument {
      * @param properties properties of the document
      * @param auditOptions audit options of the document
      *
-     * @returns a promise of the edit records of the document
-     *  Note: the edit records will not be added to the document if `noEditRecord` is true,
-     *  Call `addEditRecords` to add the edit records manually.
+     * @returns a promise of the outcome of the put properties
+     *  Symbol: S_Document_PutProperty_InvalidKey - if the key is invalid
      */
-    putProperties(properties: DocumentProperties, auditOptions?: ImbricateDocumentAuditOptions): PromiseLike<DocumentEditRecord[]>;
+    putProperties(properties: DocumentProperties, auditOptions?: ImbricateDocumentAuditOptions): PromiseLike<ImbricateDocumentPutPropertyOutcome>;
     /**
      * Put annotation to the document, optional
      *
@@ -64,25 +63,24 @@ export interface IImbricateDocument {
      * @param value value of the annotation
      * @param auditOptions audit options of the document
      *
-     * @returns a promise of the edit records of the document
-     *  Note: if the origin supports Document Edit Record, the edit record will be added by default
-     *  If you do not want to add the edit record, set `noEditRecord` to true in audit options
+     * @returns a promise of the outcome of the put annotation
+     *  Symbol: S_Document_PutAnnotation_InvalidNamespace - if the namespace is invalid
+     *  Symbol: S_Document_PutAnnotation_InvalidIdentifier - if the identifier is invalid
      */
-    putAnnotation?(namespace: string, identifier: string, value: DocumentAnnotationValue, auditOptions?: ImbricateDocumentAuditOptions): PromiseLike<DocumentEditRecord[]>;
+    putAnnotation(namespace: string, identifier: string, value: DocumentAnnotationValue, auditOptions?: ImbricateDocumentAuditOptions): PromiseLike<ImbricateDocumentPutAnnotationOutcome>;
     /**
      * Delete annotation from the document
      *
-     * RequireFeature: DOCUMENT_REMOVE_ANNOTATION
+     * RequireFeature: DOCUMENT_DELETE_ANNOTATION
      *
      * @param namespace namespace of the annotation
      * @param identifier identifier of the annotation
      * @param auditOptions audit options of the document
      *
-     * @returns a promise of the edit records of the document
-     *  Note: if the origin supports Document Edit Record, the edit record will be added by default
-     *  If you do not want to add the edit record, set `noEditRecord` to true in audit options
+     * @returns a promise of the outcome of the delete annotation
+     *  Symbol: S_Document_DeleteAnnotation_NotFound - if the annotation is not found
      */
-    deleteAnnotation?(namespace: string, identifier: string, auditOptions?: ImbricateDocumentAuditOptions): PromiseLike<DocumentEditRecord[]>;
+    deleteAnnotation(namespace: string, identifier: string, auditOptions?: ImbricateDocumentAuditOptions): PromiseLike<ImbricateDocumentDeleteAnnotationOutcome>;
     /**
      * Add edit records to the document, optional
      *  This method is optional, if not implemented, means the origin
@@ -92,8 +90,11 @@ export interface IImbricateDocument {
      * RequireFeature: DOCUMENT_PUT_EDIT_RECORD
      *
      * @param records document edit records
+     *
+     * @returns a promise of the outcome of the add edit records
+     *  Symbol: S_Document_AddEditRecords_InvalidRecord - if the record is invalid
      */
-    addEditRecords?(records: DocumentEditRecord[]): PromiseLike<void>;
+    addEditRecords(records: DocumentEditRecord[]): PromiseLike<ImbricateDocumentAddEditRecordsOutcome>;
     /**
      * Get edit records of the document, optional
      *  This method is optional, if not implemented, means the origin
@@ -102,7 +103,8 @@ export interface IImbricateDocument {
      *
      * RequireFeature: DOCUMENT_GET_EDIT_RECORD
      *
-     * @returns a promise of the edit records of the document
+     * @returns a promise of the outcome of the get edit records
+     *  Symbol: S_Document_GetEditRecords_NotFound - if the edit records are not found
      */
-    getEditRecords?(): PromiseLike<DocumentEditRecord[]>;
+    getEditRecords(): PromiseLike<ImbricateDocumentGetEditRecordsOutcome>;
 }

package/document/outcome.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @author WMXPY
+ * @namespace Document
+ * @description Outcome
+ */
+import { DocumentEditRecord } from "./definition";
+export declare const S_Document_PutProperty_InvalidKey: unique symbol;
+export type ImbricateDocumentPutPropertyOutcomeSymbol = typeof S_Document_PutProperty_InvalidKey;
+export type ImbricateDocumentPutPropertyOutcome = {
+    readonly editRecords: DocumentEditRecord[];
+} | ImbricateDocumentPutPropertyOutcomeSymbol;
+export declare const S_Document_PutAnnotation_InvalidNamespace: unique symbol;
+export declare const S_Document_PutAnnotation_InvalidIdentifier: unique symbol;
+export type ImbricateDocumentPutAnnotationOutcomeSymbol = typeof S_Document_PutAnnotation_InvalidNamespace | typeof S_Document_PutAnnotation_InvalidIdentifier;
+export type ImbricateDocumentPutAnnotationOutcome = {
+    readonly editRecords: DocumentEditRecord[];
+} | ImbricateDocumentPutAnnotationOutcomeSymbol;
+export declare const S_Document_DeleteAnnotation_NotFound: unique symbol;
+export type ImbricateDocumentDeleteAnnotationOutcomeSymbol = typeof S_Document_DeleteAnnotation_NotFound;
+export type ImbricateDocumentDeleteAnnotationOutcome = {
+    readonly editRecords: DocumentEditRecord[];
+} | ImbricateDocumentDeleteAnnotationOutcomeSymbol;
+export declare const S_Document_AddEditRecords_InvalidRecord: unique symbol;
+export type ImbricateDocumentAddEditRecordsOutcomeSymbol = typeof S_Document_AddEditRecords_InvalidRecord;
+export type ImbricateDocumentAddEditRecordsOutcome = {
+    readonly editRecords: DocumentEditRecord[];
+} | ImbricateDocumentAddEditRecordsOutcomeSymbol;
+export declare const S_Document_GetEditRecords_NotFound: unique symbol;
+export type ImbricateDocumentGetEditRecordsOutcomeSymbol = typeof S_Document_GetEditRecords_NotFound;
+export type ImbricateDocumentGetEditRecordsOutcome = {
+    readonly editRecords: DocumentEditRecord[];
+} | ImbricateDocumentGetEditRecordsOutcomeSymbol;

package/document/outcome.js

@@ -0,0 +1,19 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Document
+ * @description Outcome
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.S_Document_GetEditRecords_NotFound = exports.S_Document_AddEditRecords_InvalidRecord = exports.S_Document_DeleteAnnotation_NotFound = exports.S_Document_PutAnnotation_InvalidIdentifier = exports.S_Document_PutAnnotation_InvalidNamespace = exports.S_Document_PutProperty_InvalidKey = void 0;
+// Put Property
+exports.S_Document_PutProperty_InvalidKey = Symbol("Document_PutProperty_InvalidKey");
+// Put Annotation
+exports.S_Document_PutAnnotation_InvalidNamespace = Symbol("Document_PutAnnotation_InvalidNamespace");
+exports.S_Document_PutAnnotation_InvalidIdentifier = Symbol("Document_PutAnnotation_InvalidIdentifier");
+// Delete Annotation
+exports.S_Document_DeleteAnnotation_NotFound = Symbol("Document_DeleteAnnotation_NotFound");
+// Add Edit Records
+exports.S_Document_AddEditRecords_InvalidRecord = Symbol("Document_AddEditRecords_InvalidRecord");
+// Get Edit Records
+exports.S_Document_GetEditRecords_NotFound = Symbol("Document_GetEditRecords_NotFound");

package/error/database/database-error.d.ts

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

package/error/database/database-error.js

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

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

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

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

@@ -0,0 +1,19 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Error
+ * @description Feature Not Supported
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImbricateDatabaseFeatureNotSupportedError = void 0;
+const database_error_1 = require("./database-error");
+class ImbricateDatabaseFeatureNotSupportedError extends database_error_1.ImbricateDatabaseError {
+    static withFeature(feature) {
+        return new ImbricateDatabaseFeatureNotSupportedError(`Feature ${feature} is not supported`, feature);
+    }
+    constructor(message, reason) {
+        super(message, ImbricateDatabaseFeatureNotSupportedError.TYPE, reason);
+    }
+}
+exports.ImbricateDatabaseFeatureNotSupportedError = ImbricateDatabaseFeatureNotSupportedError;
+ImbricateDatabaseFeatureNotSupportedError.TYPE = "IMBRICATE_DATABASE_FEATURE_NOT_SUPPORTED";

package/error/database-manager/database-manager-error.d.ts

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

package/error/database-manager/database-manager-error.js

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

package/error/database-manager/feature-not-supported.d.ts

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

package/error/database-manager/feature-not-supported.js

@@ -0,0 +1,19 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Error
+ * @description Feature Not Supported
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImbricateDatabaseManagerFeatureNotSupportedError = void 0;
+const database_manager_error_1 = require("./database-manager-error");
+class ImbricateDatabaseManagerFeatureNotSupportedError extends database_manager_error_1.ImbricateDatabaseManagerError {
+    static withFeature(feature) {
+        return new ImbricateDatabaseManagerFeatureNotSupportedError(`Feature ${feature} is not supported`, feature);
+    }
+    constructor(message, reason) {
+        super(message, ImbricateDatabaseManagerFeatureNotSupportedError.TYPE, reason);
+    }
+}
+exports.ImbricateDatabaseManagerFeatureNotSupportedError = ImbricateDatabaseManagerFeatureNotSupportedError;
+ImbricateDatabaseManagerFeatureNotSupportedError.TYPE = "IMBRICATE_DATABASE_MANAGER_FEATURE_NOT_SUPPORTED";

package/error/document/document-error.d.ts

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

package/error/document/document-error.js

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

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

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