@imbricate/core 2.6.2 → 3.0.1

package/error/imbricate-error.d.ts

@@ -1,15 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Error
- * @description Imbricate
- */
-export declare class ImbricateError extends Error {
-    private readonly _type;
-    private readonly _message;
-    private readonly _reason;
-    protected constructor(message: string, type: string, reason?: any);
-    get type(): string;
-    get message(): string;
-    get reason(): any | undefined;
-    toString(): string;
-}

package/error/imbricate-error.js

@@ -1,30 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace Error
- * @description Imbricate
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImbricateError = void 0;
-class ImbricateError extends Error {
-    constructor(message, type, reason) {
-        super(message);
-        this._type = type;
-        this._message = message;
-        this._reason = reason;
-        Object.setPrototypeOf(this, ImbricateError.prototype);
-    }
-    get type() {
-        return this._type;
-    }
-    get message() {
-        return this._message;
-    }
-    get reason() {
-        return this._reason;
-    }
-    toString() {
-        return `[${this._type}] ${this.message}`;
-    }
-}
-exports.ImbricateError = ImbricateError;

package/error/not-implemented.d.ts

@@ -1,10 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Error
- * @description Not Implemented
- */
-import { ImbricateError } from "./imbricate-error";
-export declare class ImbricateNotImplemented extends ImbricateError {
-    static create(feature: string, capabilityIdentifier: string): ImbricateNotImplemented;
-    protected constructor(message: string, reason?: any);
-}

package/error/not-implemented.js

@@ -1,19 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace Error
- * @description Not Implemented
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImbricateNotImplemented = void 0;
-const imbricate_error_1 = require("./imbricate-error");
-class ImbricateNotImplemented extends imbricate_error_1.ImbricateError {
-    static create(feature, capabilityIdentifier) {
-        return new ImbricateNotImplemented(`Feature: [${feature}], which correspond with capability: [${capabilityIdentifier}] is not Implemented`);
-    }
-    constructor(message, reason) {
-        super(message, "ImbricateNotImplemented", reason);
-        Object.setPrototypeOf(this, ImbricateNotImplemented.prototype);
-    }
-}
-exports.ImbricateNotImplemented = ImbricateNotImplemented;

package/executable-manager/base.d.ts

@@ -1,21 +0,0 @@
-/**
- * @author WMXPY
- * @namespace ExecutableManager
- * @description Base
- */
-import { ImbricateCapabilityBuilder } from "../capability/builder";
-import { ImbricateCapability } from "../capability/definition";
-import { ImbricateExecuteEnvironment, ImbricateExecuteParameters, ImbricateExecuteResult } from "../execute/definition";
-import { ImbricateScriptVariant } from "../script-variant/definition";
-import { IImbricateScript } from "../script/interface";
-import { IMBRICATE_EXECUTABLE_MANAGER_CAPABILITY_KEY, ImbricateExecutableManagerCapability } from "./definition";
-import { IImbricateExecutableManager } from "./interface";
-export declare abstract class ImbricateExecutableManagerBase implements IImbricateExecutableManager {
-    static buildCapability(initial?: ImbricateCapability): ImbricateCapabilityBuilder<IMBRICATE_EXECUTABLE_MANAGER_CAPABILITY_KEY>;
-    static allAllowCapability(): ImbricateExecutableManagerCapability;
-    static allDenyCapability(): ImbricateExecutableManagerCapability;
-    abstract readonly capabilities: ImbricateExecutableManagerCapability;
-    findSupportedVariants(_variant?: Partial<ImbricateScriptVariant>): Promise<ImbricateScriptVariant[]>;
-    executeScript(_script: IImbricateScript, _parameters: ImbricateExecuteParameters, _environment: ImbricateExecuteEnvironment): Promise<ImbricateExecuteResult>;
-    executeSnippet(_snippet: string, _variant: ImbricateScriptVariant, _parameters: ImbricateExecuteParameters, _environment: ImbricateExecuteEnvironment): Promise<ImbricateExecuteResult>;
-}

package/executable-manager/base.js

@@ -1,44 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace ExecutableManager
- * @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.ImbricateExecutableManagerBase = 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 ImbricateExecutableManagerBase {
-    static buildCapability(initial = (0, definition_1.createDenyImbricateCapability)()) {
-        return builder_1.ImbricateCapabilityBuilder.create(definition_2.ImbricateExecutableManagerCapabilityList, initial);
-    }
-    static allAllowCapability() {
-        return this.buildCapability((0, definition_1.createAllowImbricateCapability)()).build();
-    }
-    static allDenyCapability() {
-        return this.buildCapability((0, definition_1.createDenyImbricateCapability)()).build();
-    }
-    findSupportedVariants(_variant) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return [];
-        });
-    }
-    executeScript(_script, _parameters, _environment) {
-        throw not_implemented_1.ImbricateNotImplemented.create("ExecuteScript", definition_2.IMBRICATE_EXECUTABLE_MANAGER_CAPABILITY_KEY.EXECUTE_SCRIPT);
-    }
-    executeSnippet(_snippet, _variant, _parameters, _environment) {
-        throw not_implemented_1.ImbricateNotImplemented.create("ExecuteSnippet", definition_2.IMBRICATE_EXECUTABLE_MANAGER_CAPABILITY_KEY.EXECUTE_SNIPPET);
-    }
-}
-exports.ImbricateExecutableManagerBase = ImbricateExecutableManagerBase;

package/executable-manager/definition.d.ts

@@ -1,12 +0,0 @@
-/**
- * @author WMXPY
- * @namespace ExecutableManager
- * @description Definition
- */
-import { ImbricateCapability } from "../capability/definition";
-export type ImbricateExecutableManagerCapability = Record<IMBRICATE_EXECUTABLE_MANAGER_CAPABILITY_KEY, ImbricateCapability>;
-export declare enum IMBRICATE_EXECUTABLE_MANAGER_CAPABILITY_KEY {
-    EXECUTE_SCRIPT = "imbricate.executable-manager.execute-script",
-    EXECUTE_SNIPPET = "imbricate.executable-manager.execute-snippet"
-}
-export declare const ImbricateExecutableManagerCapabilityList: IMBRICATE_EXECUTABLE_MANAGER_CAPABILITY_KEY[];

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 });