@imbricate/core 2.6.1 → 3.0.0

package/origin/interface.d.ts

@@ -3,67 +3,42 @@
  * @namespace Origin
  * @description Interface
  */
-import { IImbricateBinaryStorage } from "../binary-storage/interface";
-import { IImbricateCollectionManager } from "../collection-manager/interface";
-import { PromiseOr } from "../definition/promise";
-import { IImbricateFunctionManager } from "../function/interface";
-import { IImbricateOriginOperationManager } from "../origin-operation-manager/interface";
-import { IImbricateScriptManager } from "../script-manager/interface";
-import { ImbricateOriginCapability, ImbricateOriginMetadata } from "./definition";
+import { IImbricateDatabaseManager } from "../database/manager";
+import { IImbricateStaticManager } from "../static/manager";
+import { IImbricateTextManager } from "../text/manager";
+import { OriginPayload } from "./definition";
 export interface IImbricateOrigin {
-    /**
-     * Origin type
-     */
-    readonly originType: string;
     /**
      * Unique identifier of the origin
      */
     readonly uniqueIdentifier: string;
     /**
-     * Metadata of the origin
-     */
-    readonly metadata: ImbricateOriginMetadata;
-    /**
-     * Payloads of the origin
-     */
-    readonly payloads: Record<string, any>;
-    /**
-     * Capabilities of the origin
-     */
-    readonly capabilities: ImbricateOriginCapability;
-    /**
-     * Get function manager
-     *
-     * @returns Function manager
-     */
-    getFunctionManager(): IImbricateFunctionManager;
-    /**
-     * Get binary storage
-     *
-     * @returns Binary storage
+     * Payloads to initialize the origin
      */
-    getBinaryStorage(): IImbricateBinaryStorage;
+    readonly payloads: OriginPayload;
     /**
-     * Get Script manager
+     * Get the database manager of the origin
      *
-     * @returns Script manager
+     * @returns the database manager
      */
-    getScriptManager(): IImbricateScriptManager;
+    getDatabaseManager(): IImbricateDatabaseManager;
     /**
-     * Get collection manager
+     * Get the text manager of the origin
+     *  The text manager is used to manage text objects
      *
-     * @returns Collection manager
+     * @returns the text manager
      */
-    getCollectionManager(): IImbricateCollectionManager;
+    getTextManager(): IImbricateTextManager;
     /**
-     * Get operation manager
+     * Get the static manager of the origin
+     *  The static manager is used to manage static objects
      *
-     * @returns Operation manager
+     * @returns the static manager
      */
-    getOperationManager(): IImbricateOriginOperationManager;
+    getStaticManager(): IImbricateStaticManager;
     /**
      * Dispose the origin, optional
      * This method will be called when the origin is no longer needed
      */
-    dispose?(): PromiseOr<void>;
+    dispose?(): PromiseLike<void>;
 }

package/package.json

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

package/static/interface.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @author WMXPY
+ * @namespace Static
+ * @description Interface
+ */
+export interface IImbricateStatic {
+    /**
+     * Unique identifier of the static object
+     */
+    readonly uniqueIdentifier: string;
+    /**
+     * Get the content of the static object
+     *
+     * @returns a promise of the content of the text, encoded in base64
+     */
+    getContentInBase64(): PromiseLike<string>;
+}

package/{script → static}/interface.js

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

package/static/manager.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @author WMXPY
+ * @namespace Static
+ * @description Manager
+ */
+import { IImbricateStatic } from "./interface";
+export interface IImbricateStaticManager {
+    /**
+     * Get the static object from the origin
+     *
+     * @returns a promise of the static object, null if not found
+     */
+    getStatic(uniqueIdentifier: string): PromiseLike<IImbricateStatic | null>;
+    /**
+     * Create a new static object in the origin, encoded in base64
+     *  Static object is immutable, once created, it cannot be changed
+     *  Patch a new static object if you want to change the content
+     *
+     * @param content content of the static object, encoded in base64
+     * @param uniqueIdentifier unique identifier of the static object, optional
+     *  if not provided, a unique identifier will be generated
+     *
+     * @returns a promise of the created static object
+     */
+    createInBase64(content: string, uniqueIdentifier?: string): PromiseLike<IImbricateStatic>;
+}

package/{query/script.js → static/manager.js}

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

package/text/interface.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @author WMXPY
+ * @namespace Text
+ * @description Interface
+ */
+export interface IImbricateText {
+    /**
+     * Unique identifier of the text object
+     */
+    readonly uniqueIdentifier: string;
+    /**
+     * Get the content of the text object
+     *
+     * @returns a promise of the content of the text object
+     */
+    getContent(): PromiseLike<string>;
+}

package/{page → text}/interface.js

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

package/text/manager.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @author WMXPY
+ * @namespace Text
+ * @description Manager
+ */
+import { IImbricateText } from "./interface";
+export interface IImbricateTextManager {
+    /**
+     * Get the text object from the origin
+     *
+     * @returns a promise of the text object, null if not found
+     */
+    getText(uniqueIdentifier: string): PromiseLike<IImbricateText | null>;
+    /**
+     * Create a new text object in the origin
+     *  Text object is immutable, once created, it cannot be changed
+     *  Patch a new text object if you want to change the content
+     *
+     * @param content content of the text
+     * @param uniqueIdentifier unique identifier of the text object, optional
+     *  if not provided, a unique identifier will be generated
+     *
+     * @returns a promise of the text object
+     */
+    createText(content: string, uniqueIdentifier?: string): PromiseLike<IImbricateText>;
+}

package/{query/page.js → text/manager.js}

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

package/binary-storage/base.d.ts

@@ -1,18 +0,0 @@
-/**
- * @author WMXPY
- * @namespace BinaryStorage
- * @description Base
- */
-import { ImbricateCapabilityBuilder } from "../capability/builder";
-import { ImbricateCapability } from "../capability/definition";
-import type { PromiseOr } from "../definition/promise";
-import { IMBRICATE_BINARY_STORAGE_CAPABILITY_KEY, ImbricateBinaryStorageCapability } from "./definition";
-import type { IImbricateBinaryStorage } from "./interface";
-export declare abstract class ImbricateBinaryStorageBase implements IImbricateBinaryStorage {
-    static buildCapability(initial?: ImbricateCapability): ImbricateCapabilityBuilder<IMBRICATE_BINARY_STORAGE_CAPABILITY_KEY>;
-    static allAllowCapability(): ImbricateBinaryStorageCapability;
-    static allDenyCapability(): ImbricateBinaryStorageCapability;
-    abstract readonly capabilities: ImbricateBinaryStorageCapability;
-    putBinaryBase64(_binary: string, _fileName: string): PromiseOr<string>;
-    validateBinaryBase64(_binary: string): PromiseOr<boolean>;
-}

package/binary-storage/base.js

@@ -1,30 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace BinaryStorage
- * @description Base
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImbricateBinaryStorageBase = void 0;
-const builder_1 = require("../capability/builder");
-const definition_1 = require("../capability/definition");
-const not_implemented_1 = require("../error/not-implemented");
-const definition_2 = require("./definition");
-class ImbricateBinaryStorageBase {
-    static buildCapability(initial = (0, definition_1.createDenyImbricateCapability)()) {
-        return builder_1.ImbricateCapabilityBuilder.create(definition_2.ImbricateBinaryStorageCapabilityList, initial);
-    }
-    static allAllowCapability() {
-        return this.buildCapability((0, definition_1.createAllowImbricateCapability)()).build();
-    }
-    static allDenyCapability() {
-        return this.buildCapability((0, definition_1.createDenyImbricateCapability)()).build();
-    }
-    putBinaryBase64(_binary, _fileName) {
-        throw not_implemented_1.ImbricateNotImplemented.create("PutBinaryBase64", definition_2.IMBRICATE_BINARY_STORAGE_CAPABILITY_KEY.UPLOAD_FILE);
-    }
-    validateBinaryBase64(_binary) {
-        throw not_implemented_1.ImbricateNotImplemented.create("ValidateBinaryBase64", definition_2.IMBRICATE_BINARY_STORAGE_CAPABILITY_KEY.UPLOAD_FILE);
-    }
-}
-exports.ImbricateBinaryStorageBase = ImbricateBinaryStorageBase;

package/binary-storage/definition.d.ts

@@ -1,11 +0,0 @@
-/**
- * @author WMXPY
- * @namespace BinaryStorage
- * @description Definition
- */
-import type { ImbricateCapabilityRecord } from "../capability/definition";
-export type ImbricateBinaryStorageCapability = ImbricateCapabilityRecord<IMBRICATE_BINARY_STORAGE_CAPABILITY_KEY>;
-export declare enum IMBRICATE_BINARY_STORAGE_CAPABILITY_KEY {
-    UPLOAD_FILE = "imbricate.binary.storage.upload"
-}
-export declare const ImbricateBinaryStorageCapabilityList: IMBRICATE_BINARY_STORAGE_CAPABILITY_KEY[];

package/binary-storage/definition.js

@@ -1,15 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace BinaryStorage
- * @description Definition
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImbricateBinaryStorageCapabilityList = exports.IMBRICATE_BINARY_STORAGE_CAPABILITY_KEY = void 0;
-var IMBRICATE_BINARY_STORAGE_CAPABILITY_KEY;
-(function (IMBRICATE_BINARY_STORAGE_CAPABILITY_KEY) {
-    IMBRICATE_BINARY_STORAGE_CAPABILITY_KEY["UPLOAD_FILE"] = "imbricate.binary.storage.upload";
-})(IMBRICATE_BINARY_STORAGE_CAPABILITY_KEY || (exports.IMBRICATE_BINARY_STORAGE_CAPABILITY_KEY = IMBRICATE_BINARY_STORAGE_CAPABILITY_KEY = {}));
-exports.ImbricateBinaryStorageCapabilityList = [
-    IMBRICATE_BINARY_STORAGE_CAPABILITY_KEY.UPLOAD_FILE,
-];

package/binary-storage/interface.d.ts

@@ -1,26 +0,0 @@
-/**
- * @author WMXPY
- * @namespace BinaryStorage
- * @description Interface
- */
-import { PromiseOr } from "../definition/promise";
-import { ImbricateBinaryStorageCapability } from "./definition";
-export interface IImbricateBinaryStorage {
-    /**
-     * Capabilities of the binary storage
-     */
-    readonly capabilities: ImbricateBinaryStorageCapability;
-    /**
-     * Store a binary file
-     *
-     * @param binary Base64 encoded binary
-     * @param fileName File name
-     */
-    putBinaryBase64(binary: string, fileName: string): PromiseOr<string>;
-    /**
-     * Validate if the binary is a valid base64 to be stored
-     *
-     * @param binary Base64 encoded binary
-     */
-    validateBinaryBase64(binary: string): PromiseOr<boolean>;
-}

package/binary-storage/interface.js

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

package/capability/builder.d.ts

@@ -1,15 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Capability
- * @description Builder
- */
-import { ImbricateCapability, ImbricateCapabilityKey, ImbricateCapabilityRecord } from "./definition";
-export declare class ImbricateCapabilityBuilder<T extends ImbricateCapabilityKey> {
-    static create<T extends ImbricateCapabilityKey>(list: T[], initialValue: ImbricateCapability): ImbricateCapabilityBuilder<T>;
-    private readonly _capabilities;
-    private constructor();
-    set(key: T, value: ImbricateCapability): this;
-    allow(key: T): this;
-    deny(key: T): this;
-    build(): ImbricateCapabilityRecord<T>;
-}

package/capability/builder.js

@@ -1,37 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace Capability
- * @description Builder
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImbricateCapabilityBuilder = void 0;
-const create_1 = require("./create");
-const definition_1 = require("./definition");
-class ImbricateCapabilityBuilder {
-    static create(list, initialValue) {
-        const capabilities = (0, create_1.createImbricateCapabilityRecord)(list, initialValue);
-        return new ImbricateCapabilityBuilder(capabilities);
-    }
-    constructor(capabilities) {
-        this._capabilities = capabilities;
-    }
-    set(key, value) {
-        this._capabilities[key] = value;
-        return this;
-    }
-    allow(key) {
-        this._capabilities[key] = (0, definition_1.createAllowImbricateCapability)();
-        return this;
-    }
-    deny(key) {
-        this._capabilities[key] = (0, definition_1.createDenyImbricateCapability)();
-        return this;
-    }
-    build() {
-        return Object.keys(this._capabilities).reduce((previous, current) => {
-            return Object.assign(Object.assign({}, previous), { [current]: this._capabilities[current] });
-        }, {});
-    }
-}
-exports.ImbricateCapabilityBuilder = ImbricateCapabilityBuilder;

package/capability/create.d.ts

@@ -1,7 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Capability
- * @description Create
- */
-import type { ImbricateCapability, ImbricateCapabilityKey, ImbricateCapabilityRecord } from "./definition";
-export declare const createImbricateCapabilityRecord: <T extends ImbricateCapabilityKey>(list: T[], initialValue: ImbricateCapability) => ImbricateCapabilityRecord<T>;

package/capability/create.js

@@ -1,16 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace Capability
- * @description Create
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createImbricateCapabilityRecord = void 0;
-const createImbricateCapabilityRecord = (list, initialValue) => {
-    const record = {};
-    for (const key of list) {
-        record[key] = Object.assign({}, initialValue);
-    }
-    return record;
-};
-exports.createImbricateCapabilityRecord = createImbricateCapabilityRecord;

package/capability/definition.d.ts

@@ -1,16 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Capability
- * @description Definition
- */
-export type ImbricateCapabilityKey = string;
-export declare enum IMBRICATE_CAPABILITY_EFFECT {
-    ALLOW = "ALLOW",
-    DENY = "DENY"
-}
-export type ImbricateCapability = {
-    readonly effect: IMBRICATE_CAPABILITY_EFFECT;
-};
-export type ImbricateCapabilityRecord<T extends ImbricateCapabilityKey> = Record<T, ImbricateCapability>;
-export declare const createAllowImbricateCapability: () => ImbricateCapability;
-export declare const createDenyImbricateCapability: () => ImbricateCapability;

package/capability/definition.js

@@ -1,25 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace Capability
- * @description Definition
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createDenyImbricateCapability = exports.createAllowImbricateCapability = exports.IMBRICATE_CAPABILITY_EFFECT = void 0;
-var IMBRICATE_CAPABILITY_EFFECT;
-(function (IMBRICATE_CAPABILITY_EFFECT) {
-    IMBRICATE_CAPABILITY_EFFECT["ALLOW"] = "ALLOW";
-    IMBRICATE_CAPABILITY_EFFECT["DENY"] = "DENY";
-})(IMBRICATE_CAPABILITY_EFFECT || (exports.IMBRICATE_CAPABILITY_EFFECT = IMBRICATE_CAPABILITY_EFFECT = {}));
-const createAllowImbricateCapability = () => {
-    return {
-        effect: IMBRICATE_CAPABILITY_EFFECT.ALLOW,
-    };
-};
-exports.createAllowImbricateCapability = createAllowImbricateCapability;
-const createDenyImbricateCapability = () => {
-    return {
-        effect: IMBRICATE_CAPABILITY_EFFECT.DENY,
-    };
-};
-exports.createDenyImbricateCapability = createDenyImbricateCapability;

package/capability/validate.d.ts

@@ -1,19 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Capability
- * @description Validate
- */
-import { IMBRICATE_COLLECTION_CAPABILITY_KEY } from "../collection/definition";
-import type { IImbricateCollection } from "../collection/interface";
-import { IMBRICATE_ORIGIN_CAPABILITY_KEY } from "../origin/definition";
-import { IImbricateOrigin } from "../origin/interface";
-import { IMBRICATE_PAGE_CAPABILITY_KEY } from "../page/definition";
-import { IImbricatePage } from "../page/interface";
-import { IMBRICATE_SCRIPT_CAPABILITY_KEY } from "../script/definition";
-import { IImbricateScript } from "../script/interface";
-import { ImbricateCapability } from "./definition";
-export declare const validateImbricateCapability: <CapabilityRecords extends Record<string, ImbricateCapability>, KeySet extends keyof CapabilityRecords>(capabilities: CapabilityRecords, capability: KeySet) => boolean;
-export declare const validateImbricateOriginCapability: (origin: IImbricateOrigin, capability: IMBRICATE_ORIGIN_CAPABILITY_KEY) => boolean;
-export declare const validateImbricateCollectionCapability: (collection: IImbricateCollection, capability: IMBRICATE_COLLECTION_CAPABILITY_KEY) => boolean;
-export declare const validateImbricatePageCapability: (page: IImbricatePage, capability: IMBRICATE_PAGE_CAPABILITY_KEY) => boolean;
-export declare const validateImbricateScriptCapability: (script: IImbricateScript, capability: IMBRICATE_SCRIPT_CAPABILITY_KEY) => boolean;

package/capability/validate.js

@@ -1,36 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace Capability
- * @description Validate
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateImbricateScriptCapability = exports.validateImbricatePageCapability = exports.validateImbricateCollectionCapability = exports.validateImbricateOriginCapability = exports.validateImbricateCapability = void 0;
-const definition_1 = require("./definition");
-const validateImbricateCapability = (capabilities, capability) => {
-    if (!capabilities) {
-        return false;
-    }
-    const capabilityValue = capabilities[capability];
-    if (!capabilityValue) {
-        return false;
-    }
-    return capabilityValue.effect === definition_1.IMBRICATE_CAPABILITY_EFFECT.ALLOW;
-};
-exports.validateImbricateCapability = validateImbricateCapability;
-const validateImbricateOriginCapability = (origin, capability) => {
-    return (0, exports.validateImbricateCapability)(origin.capabilities, capability);
-};
-exports.validateImbricateOriginCapability = validateImbricateOriginCapability;
-const validateImbricateCollectionCapability = (collection, capability) => {
-    return (0, exports.validateImbricateCapability)(collection.capabilities, capability);
-};
-exports.validateImbricateCollectionCapability = validateImbricateCollectionCapability;
-const validateImbricatePageCapability = (page, capability) => {
-    return (0, exports.validateImbricateCapability)(page.capabilities, capability);
-};
-exports.validateImbricatePageCapability = validateImbricatePageCapability;
-const validateImbricateScriptCapability = (script, capability) => {
-    return (0, exports.validateImbricateCapability)(script.capabilities, capability);
-};
-exports.validateImbricateScriptCapability = validateImbricateScriptCapability;

package/collection/base.d.ts

@@ -1,36 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Collection
- * @description Base
- */
-import { ImbricateAuthor } from "../author/definition";
-import { ImbricateCapabilityBuilder } from "../capability/builder";
-import { ImbricateCapability } from "../capability/definition";
-import { IImbricateCollectionOperationManager } from "../collection-operation-manager/interface";
-import type { PromiseOr } from "../definition/promise";
-import { ImbricatePageVariant } from "../page-variant/definition";
-import type { ImbricatePageMetadata, ImbricatePageSearchResult, ImbricatePageSnapshot } from "../page/definition";
-import type { IImbricatePage } from "../page/interface";
-import type { ImbricatePageQuery, ImbricatePageQueryConfig, ImbricateSearchPageConfig } from "../query/page";
-import { IMBRICATE_COLLECTION_CAPABILITY_KEY, ImbricateCollectionCapability } from "./definition";
-import type { IImbricateCollection } from "./interface";
-export declare abstract class ImbricateCollectionBase implements IImbricateCollection {
-    static buildCapability(initial?: ImbricateCapability): ImbricateCapabilityBuilder<IMBRICATE_COLLECTION_CAPABILITY_KEY>;
-    static allAllowCapability(): ImbricateCollectionCapability;
-    static allDenyCapability(): ImbricateCollectionCapability;
-    abstract readonly collectionName: string;
-    abstract readonly uniqueIdentifier: string;
-    abstract readonly capabilities: ImbricateCollectionCapability;
-    createPage(_directories: string[], _title: string, _variant: ImbricatePageVariant, _author: ImbricateAuthor, _initialContent: string, _description?: string): PromiseOr<IImbricatePage>;
-    putPage(_pageMetadata: ImbricatePageMetadata, _content: string): PromiseOr<IImbricatePage>;
-    retitlePage(_identifier: string, _newTitle: string): PromiseOr<void>;
-    deletePage(_identifier: string): PromiseOr<void>;
-    hasPage(_directories: string[], _title: string): PromiseOr<boolean>;
-    getPage(_identifier: string): PromiseOr<IImbricatePage | null>;
-    listPages(_directories: string[], _recursive: boolean): PromiseOr<ImbricatePageSnapshot[]>;
-    listDirectories(_directories: string[]): PromiseOr<string[]>;
-    searchPages(_keyword: string, _config: ImbricateSearchPageConfig): PromiseOr<ImbricatePageSearchResult[]>;
-    queryPages(_query: ImbricatePageQuery, _config: ImbricatePageQueryConfig): PromiseOr<IImbricatePage[]>;
-    listSupportedVariants(): Promise<ImbricatePageVariant[]>;
-    getOperationManager(): IImbricateCollectionOperationManager;
-}

package/collection/base.js

@@ -1,60 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace Collection
- * @description Base
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImbricateCollectionBase = void 0;
-const builder_1 = require("../capability/builder");
-const definition_1 = require("../capability/definition");
-const not_implemented_1 = require("../error/not-implemented");
-const definition_2 = require("./definition");
-class ImbricateCollectionBase {
-    static buildCapability(initial = (0, definition_1.createDenyImbricateCapability)()) {
-        return builder_1.ImbricateCapabilityBuilder.create(definition_2.ImbricateCollectionCapabilityList, initial);
-    }
-    static allAllowCapability() {
-        return this.buildCapability((0, definition_1.createAllowImbricateCapability)()).build();
-    }
-    static allDenyCapability() {
-        return this.buildCapability((0, definition_1.createDenyImbricateCapability)()).build();
-    }
-    createPage(_directories, _title, _variant, _author, _initialContent, _description) {
-        throw not_implemented_1.ImbricateNotImplemented.create("CreatePage", definition_2.IMBRICATE_COLLECTION_CAPABILITY_KEY.CREATE_PAGE);
-    }
-    putPage(_pageMetadata, _content) {
-        throw not_implemented_1.ImbricateNotImplemented.create("PutPage", definition_2.IMBRICATE_COLLECTION_CAPABILITY_KEY.PUT_PAGE);
-    }
-    retitlePage(_identifier, _newTitle) {
-        throw not_implemented_1.ImbricateNotImplemented.create("RetitlePage", definition_2.IMBRICATE_COLLECTION_CAPABILITY_KEY.RETITLE_PAGE);
-    }
-    deletePage(_identifier) {
-        throw not_implemented_1.ImbricateNotImplemented.create("DeletePage", definition_2.IMBRICATE_COLLECTION_CAPABILITY_KEY.DELETE_PAGE);
-    }
-    hasPage(_directories, _title) {
-        throw not_implemented_1.ImbricateNotImplemented.create("HasPage", definition_2.IMBRICATE_COLLECTION_CAPABILITY_KEY.GET_PAGE);
-    }
-    getPage(_identifier) {
-        throw not_implemented_1.ImbricateNotImplemented.create("GetPage", definition_2.IMBRICATE_COLLECTION_CAPABILITY_KEY.GET_PAGE);
-    }
-    listPages(_directories, _recursive) {
-        throw not_implemented_1.ImbricateNotImplemented.create("ListPages", definition_2.IMBRICATE_COLLECTION_CAPABILITY_KEY.LIST_PAGES);
-    }
-    listDirectories(_directories) {
-        throw not_implemented_1.ImbricateNotImplemented.create("ListDirectories", definition_2.IMBRICATE_COLLECTION_CAPABILITY_KEY.LIST_PAGES);
-    }
-    searchPages(_keyword, _config) {
-        throw not_implemented_1.ImbricateNotImplemented.create("SearchPages", definition_2.IMBRICATE_COLLECTION_CAPABILITY_KEY.LIST_PAGES);
-    }
-    queryPages(_query, _config) {
-        throw not_implemented_1.ImbricateNotImplemented.create("QueryPages", definition_2.IMBRICATE_COLLECTION_CAPABILITY_KEY.LIST_PAGES);
-    }
-    listSupportedVariants() {
-        throw not_implemented_1.ImbricateNotImplemented.create("ListSupportedVariants", definition_2.IMBRICATE_COLLECTION_CAPABILITY_KEY.LIST_SUPPORTED_VARIANTS);
-    }
-    getOperationManager() {
-        throw not_implemented_1.ImbricateNotImplemented.create("GetOperationManager", definition_2.IMBRICATE_COLLECTION_CAPABILITY_KEY.COLLECTION_OPERATION_MANAGER);
-    }
-}
-exports.ImbricateCollectionBase = ImbricateCollectionBase;

package/collection/definition.d.ts

@@ -1,18 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Collection
- * @description Definition
- */
-import type { ImbricateCapability } from "../capability/definition";
-export type ImbricateCollectionCapability = Record<IMBRICATE_COLLECTION_CAPABILITY_KEY, ImbricateCapability>;
-export declare enum IMBRICATE_COLLECTION_CAPABILITY_KEY {
-    CREATE_PAGE = "imbricate.collection.page.create",
-    PUT_PAGE = "imbricate.collection.page.put",
-    RETITLE_PAGE = "imbricate.collection.page.retitle",
-    DELETE_PAGE = "imbricate.collection.page.delete",
-    GET_PAGE = "imbricate.collection.page.get",
-    LIST_PAGES = "imbricate.collection.page.list",
-    LIST_SUPPORTED_VARIANTS = "imbricate.collection.page.list-supported-variants",
-    COLLECTION_OPERATION_MANAGER = "imbricate.collection.operation-manager"
-}
-export declare const ImbricateCollectionCapabilityList: IMBRICATE_COLLECTION_CAPABILITY_KEY[];