@imbricate/core 2.6.1 → 3.0.0

package/executable-manager/definition.js

@@ -1,17 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace ExecutableManager
- * @description Definition
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImbricateExecutableManagerCapabilityList = exports.IMBRICATE_EXECUTABLE_MANAGER_CAPABILITY_KEY = void 0;
-var IMBRICATE_EXECUTABLE_MANAGER_CAPABILITY_KEY;
-(function (IMBRICATE_EXECUTABLE_MANAGER_CAPABILITY_KEY) {
-    IMBRICATE_EXECUTABLE_MANAGER_CAPABILITY_KEY["EXECUTE_SCRIPT"] = "imbricate.executable-manager.execute-script";
-    IMBRICATE_EXECUTABLE_MANAGER_CAPABILITY_KEY["EXECUTE_SNIPPET"] = "imbricate.executable-manager.execute-snippet";
-})(IMBRICATE_EXECUTABLE_MANAGER_CAPABILITY_KEY || (exports.IMBRICATE_EXECUTABLE_MANAGER_CAPABILITY_KEY = IMBRICATE_EXECUTABLE_MANAGER_CAPABILITY_KEY = {}));
-exports.ImbricateExecutableManagerCapabilityList = [
-    IMBRICATE_EXECUTABLE_MANAGER_CAPABILITY_KEY.EXECUTE_SCRIPT,
-    IMBRICATE_EXECUTABLE_MANAGER_CAPABILITY_KEY.EXECUTE_SNIPPET,
-];

package/executable-manager/interface.d.ts

@@ -1,44 +0,0 @@
-/**
- * @author WMXPY
- * @namespace ExecutableManager
- * @description Interface
- */
-import { PromiseOr } from "../definition/promise";
-import { ImbricateExecuteEnvironment, ImbricateExecuteParameters, ImbricateExecuteResult } from "../execute/definition";
-import { ImbricateScriptVariant } from "../script-variant/definition";
-import { IImbricateScript } from "../script/interface";
-import { ImbricateExecutableManagerCapability } from "./definition";
-export interface IImbricateExecutableManager {
-    /**
-     * Capabilities of the executable manager
-     */
-    readonly capabilities: ImbricateExecutableManagerCapability;
-    /**
-     * Find supported variants
-     *
-     * @param variant the partial variant to find, if not provided, find all
-     *
-     * @returns supported variants
-     */
-    findSupportedVariants(variant?: Partial<ImbricateScriptVariant>): PromiseOr<ImbricateScriptVariant[]>;
-    /**
-     * Execute a script
-     *
-     * @param script
-     * @param parameters
-     * @param environment
-     *
-     * @returns result of the execution
-     */
-    executeScript(script: IImbricateScript, parameters: ImbricateExecuteParameters, environment: ImbricateExecuteEnvironment): PromiseOr<ImbricateExecuteResult>;
-    /**
-     * Execute a snippet
-     *
-     * @param snippet
-     * @param parameters
-     * @param environment
-     *
-     * @returns result of the execution
-     */
-    executeSnippet(snippet: string, variant: ImbricateScriptVariant, parameters: ImbricateExecuteParameters, environment: ImbricateExecuteEnvironment): PromiseOr<ImbricateExecuteResult>;
-}

package/executable-manager/interface.js

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

package/execute/definition.d.ts

@@ -1,17 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Execute
- * @description Definition
- */
-export declare enum IMBRICATE_EXECUTE_RESULT_CODE {
-    NOT_SUPPORT = "NOT_SUPPORT",
-    SUCCESS = "SUCCESS",
-    ERROR = "ERROR",
-    EXCEPTION = "EXCEPTION",
-    TIMEOUT = "TIMEOUT"
-}
-export type ImbricateExecuteResult = {
-    readonly code: IMBRICATE_EXECUTE_RESULT_CODE;
-};
-export type ImbricateExecuteParameters = Record<string, any>;
-export type ImbricateExecuteEnvironment = Record<string, any>;

package/execute/definition.js

@@ -1,16 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace Execute
- * @description Definition
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IMBRICATE_EXECUTE_RESULT_CODE = void 0;
-var IMBRICATE_EXECUTE_RESULT_CODE;
-(function (IMBRICATE_EXECUTE_RESULT_CODE) {
-    IMBRICATE_EXECUTE_RESULT_CODE["NOT_SUPPORT"] = "NOT_SUPPORT";
-    IMBRICATE_EXECUTE_RESULT_CODE["SUCCESS"] = "SUCCESS";
-    IMBRICATE_EXECUTE_RESULT_CODE["ERROR"] = "ERROR";
-    IMBRICATE_EXECUTE_RESULT_CODE["EXCEPTION"] = "EXCEPTION";
-    IMBRICATE_EXECUTE_RESULT_CODE["TIMEOUT"] = "TIMEOUT";
-})(IMBRICATE_EXECUTE_RESULT_CODE || (exports.IMBRICATE_EXECUTE_RESULT_CODE = IMBRICATE_EXECUTE_RESULT_CODE = {}));

package/function/base.d.ts

@@ -1,19 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Function
- * @description Base
- */
-import { ImbricateCapabilityBuilder } from "../capability/builder";
-import { ImbricateCapability } from "../capability/definition";
-import type { PromiseOr } from "../definition/promise";
-import type { IImbricateOrigin } from "../origin/interface";
-import { IMBRICATE_FUNCTION_CAPABILITY_KEY, ImbricateFunction, ImbricateFunctionCapability } from "./definition";
-import type { IImbricateFunctionManager } from "./interface";
-export declare abstract class ImbricateFunctionManagerBase implements IImbricateFunctionManager {
-    static buildCapability(initial?: ImbricateCapability): ImbricateCapabilityBuilder<IMBRICATE_FUNCTION_CAPABILITY_KEY>;
-    static allAllowCapability(): ImbricateFunctionCapability;
-    static allDenyCapability(): ImbricateFunctionCapability;
-    abstract readonly capabilities: ImbricateFunctionCapability;
-    findSynchronousOriginFunctions(): Array<ImbricateFunction<IImbricateOrigin>>;
-    findAllOriginFunctions(): PromiseOr<Array<ImbricateFunction<IImbricateOrigin>>>;
-}

package/function/base.js

@@ -1,30 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace Function
- * @description Base
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImbricateFunctionManagerBase = 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 ImbricateFunctionManagerBase {
-    static buildCapability(initial = (0, definition_1.createDenyImbricateCapability)()) {
-        return builder_1.ImbricateCapabilityBuilder.create(definition_2.ImbricateFunctionCapabilityList, initial);
-    }
-    static allAllowCapability() {
-        return this.buildCapability((0, definition_1.createAllowImbricateCapability)()).build();
-    }
-    static allDenyCapability() {
-        return this.buildCapability((0, definition_1.createDenyImbricateCapability)()).build();
-    }
-    findSynchronousOriginFunctions() {
-        throw not_implemented_1.ImbricateNotImplemented.create("FindSynchronousOriginFunctions", definition_2.IMBRICATE_FUNCTION_CAPABILITY_KEY.FIND_ORIGIN_FUNCTIONS);
-    }
-    findAllOriginFunctions() {
-        throw not_implemented_1.ImbricateNotImplemented.create("FindAllOriginFunctions", definition_2.IMBRICATE_FUNCTION_CAPABILITY_KEY.FIND_ORIGIN_FUNCTIONS);
-    }
-}
-exports.ImbricateFunctionManagerBase = ImbricateFunctionManagerBase;

package/function/definition.d.ts

@@ -1,18 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Function
- * @description Definition
- */
-import { ImbricateCapability } from "../capability/definition";
-import { PromiseOr } from "../definition/promise";
-export type ImbricateFunction<Target> = {
-    readonly title: string;
-    readonly description?: string;
-    readonly execute: ImbricateFunctionExecute<Target>;
-};
-export type ImbricateFunctionExecute<Target> = (target: Target) => PromiseOr<void>;
-export type ImbricateFunctionCapability = Record<IMBRICATE_FUNCTION_CAPABILITY_KEY, ImbricateCapability>;
-export declare enum IMBRICATE_FUNCTION_CAPABILITY_KEY {
-    FIND_ORIGIN_FUNCTIONS = "imbricate.function.origin.find"
-}
-export declare const ImbricateFunctionCapabilityList: IMBRICATE_FUNCTION_CAPABILITY_KEY[];

package/function/definition.js

@@ -1,15 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace Function
- * @description Definition
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImbricateFunctionCapabilityList = exports.IMBRICATE_FUNCTION_CAPABILITY_KEY = void 0;
-var IMBRICATE_FUNCTION_CAPABILITY_KEY;
-(function (IMBRICATE_FUNCTION_CAPABILITY_KEY) {
-    IMBRICATE_FUNCTION_CAPABILITY_KEY["FIND_ORIGIN_FUNCTIONS"] = "imbricate.function.origin.find";
-})(IMBRICATE_FUNCTION_CAPABILITY_KEY || (exports.IMBRICATE_FUNCTION_CAPABILITY_KEY = IMBRICATE_FUNCTION_CAPABILITY_KEY = {}));
-exports.ImbricateFunctionCapabilityList = [
-    IMBRICATE_FUNCTION_CAPABILITY_KEY.FIND_ORIGIN_FUNCTIONS,
-];

package/function/interface.d.ts

@@ -1,26 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Function
- * @description Interface
- */
-import { PromiseOr } from "../definition/promise";
-import { IImbricateOrigin } from "../origin/interface";
-import { ImbricateFunction, ImbricateFunctionCapability } from "./definition";
-export interface IImbricateFunctionManager {
-    /**
-     * Capabilities of the function manager
-     */
-    readonly capabilities: ImbricateFunctionCapability;
-    /**
-     * Find all synchronous origin functions
-     *
-     * @returns an array of synchronous origin functions
-     */
-    findSynchronousOriginFunctions(): Array<ImbricateFunction<IImbricateOrigin>>;
-    /**
-     * Find all origin functions, including asynchronous functions and synchronous functions
-     *
-     * @returns a promise of an array of origin functions
-     */
-    findAllOriginFunctions(): PromiseOr<Array<ImbricateFunction<IImbricateOrigin>>>;
-}

package/operation/definition.d.ts

@@ -1,28 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Operation
- * @description Definition
- */
-import { PromiseOr } from "../definition/promise";
-export declare enum IMBRICATE_OPERATION_SCOPE {
-    ORIGIN = "imbricate.origin",
-    COLLECTION = "imbricate.collection",
-    PAGE = "imbricate.page"
-}
-export type ImbricateOperation<T extends IMBRICATE_OPERATION_SCOPE> = {
-    readonly operationIdentifier: string;
-    readonly operationDisplayName?: string;
-    readonly operationDescription?: string;
-    readonly scope: T;
-    readonly operation: (parameter: ImbricateOperationParameter<T>) => PromiseOr<void>;
-};
-export type ImbricateOperationParameter<T extends IMBRICATE_OPERATION_SCOPE> = T extends IMBRICATE_OPERATION_SCOPE.ORIGIN ? {
-    readonly originUniqueIdentifier: string;
-} : T extends IMBRICATE_OPERATION_SCOPE.COLLECTION ? {
-    readonly originUniqueIdentifier: string;
-    readonly collectionUniqueIdentifier: string;
-} : T extends IMBRICATE_OPERATION_SCOPE.PAGE ? {
-    readonly originUniqueIdentifier: string;
-    readonly collectionUniqueIdentifier: string;
-    readonly pageIdentifier: string;
-} : unknown;

package/operation/definition.js

@@ -1,14 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace Operation
- * @description Definition
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IMBRICATE_OPERATION_SCOPE = void 0;
-var IMBRICATE_OPERATION_SCOPE;
-(function (IMBRICATE_OPERATION_SCOPE) {
-    IMBRICATE_OPERATION_SCOPE["ORIGIN"] = "imbricate.origin";
-    IMBRICATE_OPERATION_SCOPE["COLLECTION"] = "imbricate.collection";
-    IMBRICATE_OPERATION_SCOPE["PAGE"] = "imbricate.page";
-})(IMBRICATE_OPERATION_SCOPE || (exports.IMBRICATE_OPERATION_SCOPE = IMBRICATE_OPERATION_SCOPE = {}));

package/origin/base.d.ts

@@ -1,29 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Origin
- * @description Base
- */
-import type { IImbricateBinaryStorage } from "../binary-storage/interface";
-import { ImbricateCapabilityBuilder } from "../capability/builder";
-import { ImbricateCapability } from "../capability/definition";
-import { IImbricateCollectionManager } from "../collection-manager/interface";
-import type { IImbricateFunctionManager } from "../function/interface";
-import { IImbricateOriginOperationManager } from "../origin-operation-manager/interface";
-import type { IImbricateOrigin } from "../origin/interface";
-import { IImbricateScriptManager } from "../script-manager/interface";
-import { IMBRICATE_ORIGIN_CAPABILITY_KEY, ImbricateOriginCapability, ImbricateOriginMetadata } from "./definition";
-export declare abstract class ImbricateOriginBase implements IImbricateOrigin {
-    static buildCapability(initial?: ImbricateCapability): ImbricateCapabilityBuilder<IMBRICATE_ORIGIN_CAPABILITY_KEY>;
-    static allAllowCapability(): ImbricateOriginCapability;
-    static allDenyCapability(): ImbricateOriginCapability;
-    abstract readonly originType: string;
-    abstract readonly uniqueIdentifier: string;
-    abstract readonly metadata: ImbricateOriginMetadata;
-    abstract readonly payloads: Record<string, any>;
-    abstract readonly capabilities: ImbricateOriginCapability;
-    getFunctionManager(): IImbricateFunctionManager;
-    getBinaryStorage(): IImbricateBinaryStorage;
-    getScriptManager(): IImbricateScriptManager;
-    getCollectionManager(): IImbricateCollectionManager;
-    getOperationManager(): IImbricateOriginOperationManager;
-}

package/origin/base.js

@@ -1,39 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace Origin
- * @description Base
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImbricateOriginBase = 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 ImbricateOriginBase {
-    static buildCapability(initial = (0, definition_1.createDenyImbricateCapability)()) {
-        return builder_1.ImbricateCapabilityBuilder.create(definition_2.ImbricateOriginCapabilityList, initial);
-    }
-    static allAllowCapability() {
-        return this.buildCapability((0, definition_1.createAllowImbricateCapability)()).build();
-    }
-    static allDenyCapability() {
-        return this.buildCapability((0, definition_1.createDenyImbricateCapability)()).build();
-    }
-    getFunctionManager() {
-        throw not_implemented_1.ImbricateNotImplemented.create("GetFunctionManager", definition_2.IMBRICATE_ORIGIN_CAPABILITY_KEY.ORIGIN_FUNCTION);
-    }
-    getBinaryStorage() {
-        throw not_implemented_1.ImbricateNotImplemented.create("GetBinaryStorage", definition_2.IMBRICATE_ORIGIN_CAPABILITY_KEY.ORIGIN_BINARY_STORAGE);
-    }
-    getScriptManager() {
-        throw not_implemented_1.ImbricateNotImplemented.create("GetScriptManager", definition_2.IMBRICATE_ORIGIN_CAPABILITY_KEY.ORIGIN_SCRIPT_MANAGER);
-    }
-    getCollectionManager() {
-        throw not_implemented_1.ImbricateNotImplemented.create("GetCollectionManager", definition_2.IMBRICATE_ORIGIN_CAPABILITY_KEY.ORIGIN_COLLECTION_MANAGER);
-    }
-    getOperationManager() {
-        throw not_implemented_1.ImbricateNotImplemented.create("GetOperationManager", definition_2.IMBRICATE_ORIGIN_CAPABILITY_KEY.ORIGIN_OPERATION_MANAGER);
-    }
-}
-exports.ImbricateOriginBase = ImbricateOriginBase;

package/origin-operation-manager/base.d.ts

@@ -1,18 +0,0 @@
-/**
- * @author WMXPY
- * @namespace OriginOperationManager
- * @description Base
- */
-import { ImbricateCapabilityBuilder } from "../capability/builder";
-import { ImbricateCapability } from "../capability/definition";
-import { IMBRICATE_OPERATION_SCOPE, ImbricateOperation } from "../operation/definition";
-import { IMBRICATE_ORIGIN_OPERATION_MANAGER_CAPABILITY_KEY, ImbricateOriginOperationManagerCapability } from "./definition";
-import { IImbricateOriginOperationManager } from "./interface";
-export declare abstract class ImbricateOriginOperationManagerBase implements IImbricateOriginOperationManager {
-    static buildCapability(initial?: ImbricateCapability): ImbricateCapabilityBuilder<IMBRICATE_ORIGIN_OPERATION_MANAGER_CAPABILITY_KEY>;
-    static allAllowCapability(): ImbricateOriginOperationManagerCapability;
-    static allDenyCapability(): ImbricateOriginOperationManagerCapability;
-    abstract readonly capabilities: ImbricateOriginOperationManagerCapability;
-    listOperations(_scope?: IMBRICATE_OPERATION_SCOPE): Promise<Array<ImbricateOperation<IMBRICATE_OPERATION_SCOPE>>>;
-    executeOperation(_operationIdentifier: string, _parameter: unknown): Promise<void>;
-}

package/origin-operation-manager/base.js

@@ -1,43 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace OriginOperationManager
- * @description Base
- */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImbricateOriginOperationManagerBase = 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 ImbricateOriginOperationManagerBase {
-    static buildCapability(initial = (0, definition_1.createDenyImbricateCapability)()) {
-        return builder_1.ImbricateCapabilityBuilder.create(definition_2.ImbricateOriginOperationManagerCapabilityList, initial);
-    }
-    static allAllowCapability() {
-        return this.buildCapability((0, definition_1.createAllowImbricateCapability)()).build();
-    }
-    static allDenyCapability() {
-        return this.buildCapability((0, definition_1.createDenyImbricateCapability)()).build();
-    }
-    listOperations(_scope) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw not_implemented_1.ImbricateNotImplemented.create("ListOperations", definition_2.IMBRICATE_ORIGIN_OPERATION_MANAGER_CAPABILITY_KEY.LIST_OPERATIONS);
-        });
-    }
-    executeOperation(_operationIdentifier, _parameter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw not_implemented_1.ImbricateNotImplemented.create("ExecuteOperation", definition_2.IMBRICATE_ORIGIN_OPERATION_MANAGER_CAPABILITY_KEY.EXECUTE_OPERATION);
-        });
-    }
-}
-exports.ImbricateOriginOperationManagerBase = ImbricateOriginOperationManagerBase;

package/origin-operation-manager/definition.d.ts

@@ -1,12 +0,0 @@
-/**
- * @author WMXPY
- * @namespace OriginOperationManager
- * @description Definition
- */
-import { ImbricateCapability } from "../capability/definition";
-export type ImbricateOriginOperationManagerCapability = Record<IMBRICATE_ORIGIN_OPERATION_MANAGER_CAPABILITY_KEY, ImbricateCapability>;
-export declare enum IMBRICATE_ORIGIN_OPERATION_MANAGER_CAPABILITY_KEY {
-    LIST_OPERATIONS = "imbricate.origin-operation.list",
-    EXECUTE_OPERATION = "imbricate.origin-operation.execute"
-}
-export declare const ImbricateOriginOperationManagerCapabilityList: IMBRICATE_ORIGIN_OPERATION_MANAGER_CAPABILITY_KEY[];

package/origin-operation-manager/definition.js

@@ -1,17 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace OriginOperationManager
- * @description Definition
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImbricateOriginOperationManagerCapabilityList = exports.IMBRICATE_ORIGIN_OPERATION_MANAGER_CAPABILITY_KEY = void 0;
-var IMBRICATE_ORIGIN_OPERATION_MANAGER_CAPABILITY_KEY;
-(function (IMBRICATE_ORIGIN_OPERATION_MANAGER_CAPABILITY_KEY) {
-    IMBRICATE_ORIGIN_OPERATION_MANAGER_CAPABILITY_KEY["LIST_OPERATIONS"] = "imbricate.origin-operation.list";
-    IMBRICATE_ORIGIN_OPERATION_MANAGER_CAPABILITY_KEY["EXECUTE_OPERATION"] = "imbricate.origin-operation.execute";
-})(IMBRICATE_ORIGIN_OPERATION_MANAGER_CAPABILITY_KEY || (exports.IMBRICATE_ORIGIN_OPERATION_MANAGER_CAPABILITY_KEY = IMBRICATE_ORIGIN_OPERATION_MANAGER_CAPABILITY_KEY = {}));
-exports.ImbricateOriginOperationManagerCapabilityList = [
-    IMBRICATE_ORIGIN_OPERATION_MANAGER_CAPABILITY_KEY.LIST_OPERATIONS,
-    IMBRICATE_ORIGIN_OPERATION_MANAGER_CAPABILITY_KEY.EXECUTE_OPERATION,
-];

package/origin-operation-manager/interface.d.ts

@@ -1,34 +0,0 @@
-/**
- * @author WMXPY
- * @namespace OriginOperationManager
- * @description Interface
- */
-import { PromiseOr } from "../definition/promise";
-import { IMBRICATE_OPERATION_SCOPE, ImbricateOperation, ImbricateOperationParameter } from "../operation/definition";
-import { ImbricateOriginOperationManagerCapability } from "./definition";
-export interface IImbricateOriginOperationManager {
-    /**
-     * Capabilities of the origin operation manager
-     */
-    readonly capabilities: ImbricateOriginOperationManagerCapability;
-    /**
-     * List all operations
-     *
-     * @returns all operations
-     */
-    listOperations(): PromiseOr<Array<ImbricateOperation<IMBRICATE_OPERATION_SCOPE>>>;
-    /**
-     * List operations by scope
-     *
-     * @param scope the scope of the operation
-     * @returns all operations
-     */
-    listOperations<T extends IMBRICATE_OPERATION_SCOPE>(scope: IMBRICATE_OPERATION_SCOPE): PromiseOr<Array<ImbricateOperation<T>>>;
-    /**
-     * Execute operation by identifier
-     *
-     * @param operationIdentifier the identifier of the operation
-     * @param parameter the parameter of the operation
-     */
-    executeOperation<T extends IMBRICATE_OPERATION_SCOPE>(operationIdentifier: string, parameter: ImbricateOperationParameter<T>): PromiseOr<void>;
-}

package/origin-operation-manager/interface.js

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

package/page/base.d.ts

@@ -1,35 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Page
- * @description Base
- */
-import { ImbricateAuthor } from "../author/definition";
-import { ImbricateCapabilityBuilder } from "../capability/builder";
-import { ImbricateCapability } from "../capability/definition";
-import type { PromiseOr } from "../definition/promise";
-import { ImbricatePageVariant } from "../page-variant/definition";
-import { IMBRICATE_PAGE_CAPABILITY_KEY, ImbricatePageCapability, ImbricatePageHistoryRecord } from "./definition";
-import type { IImbricatePage } from "./interface";
-export declare abstract class ImbricatePageBase implements IImbricatePage {
-    static buildCapability(initial?: ImbricateCapability): ImbricateCapabilityBuilder<IMBRICATE_PAGE_CAPABILITY_KEY>;
-    static allAllowCapability(): ImbricatePageCapability;
-    static allDenyCapability(): ImbricatePageCapability;
-    abstract readonly title: string;
-    abstract readonly directories: string[];
-    abstract readonly identifier: string;
-    abstract readonly variant: ImbricatePageVariant;
-    abstract readonly digest: string;
-    abstract readonly historyRecords: ImbricatePageHistoryRecord[];
-    abstract readonly description?: string;
-    abstract readonly createdAt: Date;
-    abstract readonly updatedAt: Date;
-    abstract readonly capabilities: ImbricatePageCapability;
-    readContent(): PromiseOr<string>;
-    writeContent(_content: string): PromiseOr<void>;
-    readAttributes(): PromiseOr<Record<string, string>>;
-    writeAttribute(_key: string, _value: string): PromiseOr<void>;
-    refreshUpdateMetadata(_updatedAt: Date, _digest: string, _author: ImbricateAuthor): PromiseOr<void>;
-    refreshUpdatedAt(_updatedAt: Date): PromiseOr<void>;
-    refreshDigest(_digest: string): PromiseOr<void>;
-    addHistoryRecord(_record: ImbricatePageHistoryRecord): PromiseOr<void>;
-}

package/page/base.js

@@ -1,48 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace Page
- * @description Base
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImbricatePageBase = 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 ImbricatePageBase {
-    static buildCapability(initial = (0, definition_1.createDenyImbricateCapability)()) {
-        return builder_1.ImbricateCapabilityBuilder.create(definition_2.ImbricatePageCapabilityList, initial);
-    }
-    static allAllowCapability() {
-        return this.buildCapability((0, definition_1.createAllowImbricateCapability)()).build();
-    }
-    static allDenyCapability() {
-        return this.buildCapability((0, definition_1.createDenyImbricateCapability)()).build();
-    }
-    readContent() {
-        throw not_implemented_1.ImbricateNotImplemented.create("ReadContent", definition_2.IMBRICATE_PAGE_CAPABILITY_KEY.READ);
-    }
-    writeContent(_content) {
-        throw not_implemented_1.ImbricateNotImplemented.create("WriteContent", definition_2.IMBRICATE_PAGE_CAPABILITY_KEY.WRITE);
-    }
-    readAttributes() {
-        throw not_implemented_1.ImbricateNotImplemented.create("ReadAttributes", definition_2.IMBRICATE_PAGE_CAPABILITY_KEY.READ_ATTRIBUTE);
-    }
-    writeAttribute(_key, _value) {
-        throw not_implemented_1.ImbricateNotImplemented.create("WriteAttribute", definition_2.IMBRICATE_PAGE_CAPABILITY_KEY.WRITE_ATTRIBUTE);
-    }
-    refreshUpdateMetadata(_updatedAt, _digest, _author) {
-        throw not_implemented_1.ImbricateNotImplemented.create("RefreshUpdateMetadata", definition_2.IMBRICATE_PAGE_CAPABILITY_KEY.UPDATE_METADATA);
-    }
-    refreshUpdatedAt(_updatedAt) {
-        throw not_implemented_1.ImbricateNotImplemented.create("RefreshUpdatedAt", definition_2.IMBRICATE_PAGE_CAPABILITY_KEY.UPDATE_METADATA);
-    }
-    refreshDigest(_digest) {
-        throw not_implemented_1.ImbricateNotImplemented.create("RefreshDigest", definition_2.IMBRICATE_PAGE_CAPABILITY_KEY.UPDATE_METADATA);
-    }
-    addHistoryRecord(_record) {
-        throw not_implemented_1.ImbricateNotImplemented.create("AddHistoryRecord", definition_2.IMBRICATE_PAGE_CAPABILITY_KEY.UPDATE_HISTORY_RECORD);
-    }
-}
-exports.ImbricatePageBase = ImbricatePageBase;

package/page/definition.d.ts

@@ -1,41 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Page
- * @description Definition
- */
-import { ImbricateAuthor } from "../author/definition";
-import { ImbricateCapability } from "../capability/definition";
-import { ImbricatePageVariant } from "../page-variant/definition";
-import { IMBRICATE_SEARCH_RESULT_TYPE, ImbricateSearchResult, ImbricateSearchSnippet } from "../search/snippet";
-export type ImbricatePageAttributes = Record<string, string>;
-export type ImbricatePageSearchResult = ImbricateSearchResult<IMBRICATE_SEARCH_RESULT_TYPE.PAGE>;
-export type ImbricatePageSearchSnippet = ImbricateSearchSnippet<IMBRICATE_SEARCH_RESULT_TYPE.PAGE>;
-export type ImbricatePageSnapshot = {
-    readonly title: string;
-    readonly directories: string[];
-    readonly identifier: string;
-    readonly variant: ImbricatePageVariant;
-};
-export type ImbricatePageHistoryRecord = {
-    readonly author: ImbricateAuthor;
-    readonly digest: string;
-    readonly updatedAt: Date;
-};
-export type ImbricatePageMetadata = {
-    readonly createdAt: Date;
-    readonly digest: string;
-    readonly updatedAt: Date;
-    readonly attributes: ImbricatePageAttributes;
-    readonly historyRecords: ImbricatePageHistoryRecord[];
-    readonly description?: string;
-} & ImbricatePageSnapshot;
-export type ImbricatePageCapability = Record<IMBRICATE_PAGE_CAPABILITY_KEY, ImbricateCapability>;
-export declare enum IMBRICATE_PAGE_CAPABILITY_KEY {
-    READ = "imbricate.page.read",
-    WRITE = "imbricate.page.write",
-    READ_ATTRIBUTE = "imbricate.page.attribute.read",
-    WRITE_ATTRIBUTE = "imbricate.page.attribute.write",
-    UPDATE_METADATA = "imbricate.page.metadata.update",
-    UPDATE_HISTORY_RECORD = "imbricate.page.history.update"
-}
-export declare const ImbricatePageCapabilityList: IMBRICATE_PAGE_CAPABILITY_KEY[];

package/page/definition.js

@@ -1,25 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace Page
- * @description Definition
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImbricatePageCapabilityList = exports.IMBRICATE_PAGE_CAPABILITY_KEY = void 0;
-var IMBRICATE_PAGE_CAPABILITY_KEY;
-(function (IMBRICATE_PAGE_CAPABILITY_KEY) {
-    IMBRICATE_PAGE_CAPABILITY_KEY["READ"] = "imbricate.page.read";
-    IMBRICATE_PAGE_CAPABILITY_KEY["WRITE"] = "imbricate.page.write";
-    IMBRICATE_PAGE_CAPABILITY_KEY["READ_ATTRIBUTE"] = "imbricate.page.attribute.read";
-    IMBRICATE_PAGE_CAPABILITY_KEY["WRITE_ATTRIBUTE"] = "imbricate.page.attribute.write";
-    IMBRICATE_PAGE_CAPABILITY_KEY["UPDATE_METADATA"] = "imbricate.page.metadata.update";
-    IMBRICATE_PAGE_CAPABILITY_KEY["UPDATE_HISTORY_RECORD"] = "imbricate.page.history.update";
-})(IMBRICATE_PAGE_CAPABILITY_KEY || (exports.IMBRICATE_PAGE_CAPABILITY_KEY = IMBRICATE_PAGE_CAPABILITY_KEY = {}));
-exports.ImbricatePageCapabilityList = [
-    IMBRICATE_PAGE_CAPABILITY_KEY.READ,
-    IMBRICATE_PAGE_CAPABILITY_KEY.WRITE,
-    IMBRICATE_PAGE_CAPABILITY_KEY.READ_ATTRIBUTE,
-    IMBRICATE_PAGE_CAPABILITY_KEY.WRITE_ATTRIBUTE,
-    IMBRICATE_PAGE_CAPABILITY_KEY.UPDATE_METADATA,
-    IMBRICATE_PAGE_CAPABILITY_KEY.UPDATE_HISTORY_RECORD,
-];