@jumoo/processing 17.4.2

package/dist/pipeline/pipeline.element.js

@@ -0,0 +1,260 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { css, customElement, html, nothing, property, state, } from '@umbraco-cms/backoffice/external/lit';
+import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
+import { PipelineStatus, JUMOO_PROCESSING_CONTEXT, } from '@jumoo/processing';
+/**
+ * @property {string} processor - the processor to use for the pipeline
+ * @property {string} strategy - the strategy to use for the pipeline
+ * @property {ProcessingOptions} options - the options to see the pipeline with
+ *
+ * @fires pipeline-complete - when the pipeline is complete
+ * @fires pipeline-waiting - when the pipeline is waiting for user input
+ * @fires pipeline-last-action - when the pipeline is on the last action
+ * @fires pipeline-status - the current status of the pipeline.
+ */
+let JumooPipelineElement = class JumooPipelineElement extends UmbLitElement {
+    constructor() {
+        super();
+        /**
+         * @description - show debug information
+         */
+        this.debug = false;
+        this.consumeContext(JUMOO_PROCESSING_CONTEXT, (context) => {
+            if (!context)
+                return;
+            this.context = context;
+            this.observe(this.context.trigger, async (trigger) => {
+                if (trigger === true) {
+                    await this.process();
+                    this.context?.clearNext();
+                }
+            });
+            this.observe(this.context.close, async (close) => {
+                if (close === true) {
+                    this.context?.triggerFinalized();
+                }
+            });
+            this.observe(this.context.pipeline, (pipeline) => {
+                this._pipelineId = pipeline;
+                if (this._pipelineId) {
+                    this.context?.getPipeline(this._pipelineId);
+                }
+            });
+            this.observe(this.context.state, (state) => {
+                this.state = state;
+                if (this.state) {
+                    this.dispatchEvent(new CustomEvent('pipeline-status', {
+                        bubbles: true,
+                        composed: true,
+                        detail: {
+                            status: this.state?.status,
+                            isLastAction: this.state?.progress.isLastAction,
+                        },
+                    }));
+                }
+                if (this.state?.progress.isLastAction === true) {
+                    this.onLastAction();
+                }
+            });
+            this.observe(this.context?.backgroundState, (backgroundState) => {
+                this.backgroundState = backgroundState;
+            });
+            this.observe(this.context.options, (options) => {
+                this.options = options;
+            });
+            this.observe(this.context.message, (message) => {
+                this.message = message;
+            });
+            this.observe(this.context.results, (results) => {
+                this.results = results;
+            });
+        });
+    }
+    connectedCallback() {
+        super.connectedCallback();
+        if (this.pipelineId) {
+            this.context?.loadPipeline(this.pipelineId);
+        }
+        else if (this.strategy && this.processor) {
+            this.options = this.setup;
+            this.context?.createPipeline(this.processor, this.strategy, this.setup);
+        }
+    }
+    async process() {
+        let result;
+        do {
+            result = await this.context?.process();
+        } while (result?.state.status == PipelineStatus.RUNNING);
+        // either complete, or waiting for user.
+        switch (result?.state.status) {
+            case PipelineStatus.COMPLETED:
+                this.onComplete();
+                break;
+            case PipelineStatus.BACKGROUND:
+                this.onBackground();
+                break;
+            default:
+                this.onWaiting();
+                break;
+        }
+    }
+    /**
+     * @description dispatches a named custom event, with the pipelineId and state,
+     * @param name name of event to file
+     */
+    fireEvent(name) {
+        this.dispatchEvent(new CustomEvent(name, {
+            bubbles: true,
+            composed: true,
+            detail: {
+                pielineId: this._pipelineId,
+                state: this.state,
+            },
+        }));
+    }
+    onBackground() {
+        this.fireEvent('pipeline-background');
+    }
+    /**
+     * @description when the pipeline is complete
+     */
+    onComplete() {
+        this.fireEvent('pipeline-complete');
+    }
+    /**
+     * @description when the pipeline is waiting for user input (via an element.)
+     */
+    onWaiting() {
+        this.fireEvent('pipeline-waiting');
+    }
+    /**
+     * @description when the pipeline is on its last action
+     */
+    onLastAction() {
+        this.fireEvent('pipeline-last-action');
+    }
+    render() {
+        return html `${this.renderStatus()}${this.renderDebug()}`;
+    }
+    renderDebug() {
+        return this.debug
+            ? html `<div><pre>${JSON.stringify(this.state, null, 1)}</pre></div>`
+            : nothing;
+    }
+    renderStatus() {
+        switch (this.state?.status) {
+            case PipelineStatus.COMPLETED:
+                return this.renderComplete();
+            case PipelineStatus.WAITING:
+                return this.renderElement(this.state?.elementName);
+            case PipelineStatus.RUNNING:
+                return this.renderSteps();
+            case PipelineStatus.FAILED:
+                return this.renderFail();
+            case PipelineStatus.BACKGROUND:
+                return this.renderBackground();
+            default:
+                return nothing;
+        }
+    }
+    renderBackground() {
+        return !this.state?.backgroundState?.backgroundElement
+            ? html `<jumoo-pipeline-background
+					.message=${this.message}
+					.state=${this.backgroundState ?? this.state}
+					.pipelineId=${this._pipelineId}
+					.background=${this.state?.backgroundState}
+					.options=${this.options}></jumoo-pipeline-background>`
+            : this.renderElement(this.state?.backgroundState?.backgroundElement);
+    }
+    renderComplete() {
+        return !this.state?.backgroundState?.completedElement
+            ? !this.state?.currentRequest?.action?.element
+                ? html `<div>complete</div>`
+                : this.renderElement(this.state?.currentRequest?.action?.element)
+            : html `<jumoo-pipeline-background
+					.message=${this.message}
+					.state=${this.backgroundState ?? this.state}
+					.pipelineId=${this._pipelineId}
+					.background=${this.state?.backgroundState}
+					.options=${this.options}></jumoo-pipeline-background>`;
+    }
+    renderSteps() {
+        if (!this.state?.progress)
+            return nothing;
+        return html `<jumoo-pipeline-progress
+			.progress=${this.state?.progress}
+			.message=${this.message}></jumoo-pipeline-progress>`;
+    }
+    renderElement(element) {
+        return !element
+            ? nothing
+            : html `
+					<div class="wrapper">
+						<umb-extension-slot
+							type="jumoo-process-step"
+							.filter=${(ext) => ext.elementName === element}
+							.props=${{
+                pipelineId: this._pipelineId,
+                state: this.state,
+                options: this.options,
+                results: this.results,
+            }}></umb-extension-slot>
+					</div>
+				`;
+    }
+    renderFail() {
+        return html `
+			<jumoo-processing-error .error=${this.results?.error}></jumoo-processing-error>
+		`;
+    }
+};
+JumooPipelineElement.styles = css `
+		.wrapper,
+		umb-extension-slot {
+			height: 100%;
+		}
+	`;
+__decorate([
+    property({ type: String })
+], JumooPipelineElement.prototype, "processor", void 0);
+__decorate([
+    property({ type: String })
+], JumooPipelineElement.prototype, "strategy", void 0);
+__decorate([
+    property({ type: Object })
+], JumooPipelineElement.prototype, "setup", void 0);
+__decorate([
+    property({ type: String })
+], JumooPipelineElement.prototype, "pipelineId", void 0);
+__decorate([
+    property({ type: Boolean })
+], JumooPipelineElement.prototype, "debug", void 0);
+__decorate([
+    state()
+], JumooPipelineElement.prototype, "_pipelineId", void 0);
+__decorate([
+    state()
+], JumooPipelineElement.prototype, "options", void 0);
+__decorate([
+    state()
+], JumooPipelineElement.prototype, "state", void 0);
+__decorate([
+    state()
+], JumooPipelineElement.prototype, "results", void 0);
+__decorate([
+    state()
+], JumooPipelineElement.prototype, "message", void 0);
+__decorate([
+    state()
+], JumooPipelineElement.prototype, "backgroundState", void 0);
+JumooPipelineElement = __decorate([
+    customElement('jumoo-pipeline')
+], JumooPipelineElement);
+export { JumooPipelineElement };
+export default JumooPipelineElement;

package/dist/pipeline/pipeline.repository.d.ts

@@ -0,0 +1,20 @@
+import { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
+import { UmbControllerBase } from '@umbraco-cms/backoffice/class-api';
+import { PipelineStatus, ProcessingOptions } from '@jumoo/processing';
+/**
+ * @description repository for the pipeline
+ */
+export declare class PipelineRepository extends UmbControllerBase {
+    private readonly source;
+    constructor(host: UmbControllerHost);
+    clear(id: string): Promise<unknown>;
+    process(id: string, clientId: string | null): Promise<import("@jumoo/processing").Pipeline>;
+    reattach(id: string, clientId: string | null): Promise<import("@jumoo/processing").Pipeline>;
+    update(id: string, body: any): Promise<import("@jumoo/processing").ProcessingOptionsResults>;
+    getProcessors(): Promise<string[]>;
+    Get(id: string): Promise<import("@jumoo/processing").Pipeline>;
+    create(processor: string, strategy: string, options: ProcessingOptions | undefined): Promise<string>;
+    complete(id: string): Promise<void>;
+    getResults(id: string): Promise<import("@jumoo/processing").ProcessingResults>;
+    listPipelines(status: PipelineStatus): Promise<import("@jumoo/processing").Pipeline[]>;
+}

package/dist/pipeline/pipeline.repository.js

@@ -0,0 +1,41 @@
+import { UmbControllerBase } from '@umbraco-cms/backoffice/class-api';
+import { PipelineSource } from '@jumoo/processing';
+/**
+ * @description repository for the pipeline
+ */
+export class PipelineRepository extends UmbControllerBase {
+    constructor(host) {
+        super(host);
+        this.source = new PipelineSource(host);
+    }
+    async clear(id) {
+        return (await this.source.clear(id)).data;
+    }
+    async process(id, clientId) {
+        return (await this.source.process(id, clientId)).data;
+    }
+    async reattach(id, clientId) {
+        return (await this.source.reattach(id, clientId)).data;
+    }
+    async update(id, body) {
+        return (await this.source.update(id, body)).data;
+    }
+    async getProcessors() {
+        return (await this.source.getProcessors()).data;
+    }
+    async Get(id) {
+        return (await this.source.Get(id)).data;
+    }
+    async create(processor, strategy, options) {
+        return (await this.source.create(processor, strategy, options)).data;
+    }
+    async complete(id) {
+        console.debug('complete', id);
+    }
+    async getResults(id) {
+        return (await this.source.getResults(id)).data;
+    }
+    async listPipelines(status) {
+        return (await this.source.listPiplelines(status)).data;
+    }
+}

package/dist/pipeline/pipeline.source.d.ts

@@ -0,0 +1,76 @@
+import { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
+import { PipelineStatus } from '../api';
+export declare class PipelineSource {
+    private readonly host;
+    constructor(host: UmbControllerHost);
+    process(id: string, clientId: string | null): Promise<import("@umbraco-cms/backoffice/resources").UmbApiResponse<{
+        data: import("..").Pipeline;
+        request: Request;
+        response: Response;
+    }>>;
+    /**
+     * @description re-registers a client id against a pipeline already running in the
+     * background (e.g. after a SignalR reconnect gave the browser a new connection id), and
+     * returns the full, current pipeline so the caller can resync rather than trust whatever it
+     * last saw down the old, now-dead connection.
+     */
+    reattach(id: string, clientId: string | null): Promise<import("@umbraco-cms/backoffice/resources").UmbApiResponse<{
+        data: import("..").Pipeline;
+        request: Request;
+        response: Response;
+    }>>;
+    update(id: string, body: any): Promise<import("@umbraco-cms/backoffice/resources").UmbApiResponse<{
+        data: import("..").ProcessingOptionsResults;
+        request: Request;
+        response: Response;
+    }>>;
+    getProcessors(): Promise<import("@umbraco-cms/backoffice/resources").UmbApiResponse<{
+        data: string[];
+        request: Request;
+        response: Response;
+    }>>;
+    /**
+     *
+     * @param id guid id of the pipeline to retrieve
+     * @returns pipeline
+     */
+    Get(id: string): Promise<import("@umbraco-cms/backoffice/resources").UmbApiResponse<{
+        data: import("..").Pipeline;
+        request: Request;
+        response: Response;
+    }>>;
+    /**
+     *
+     * @param strategy alias of the strategy to use for the pipeline
+     * @returns
+     */
+    create(processor: string, strategy: string, options: any): Promise<import("@umbraco-cms/backoffice/resources").UmbApiResponse<{
+        data: string;
+        request: Request;
+        response: Response;
+    }>>;
+    /**
+     *
+     * @param id guid id of the pipeline to remove
+     * @returns nothing.
+     */
+    clear(id: string): Promise<import("@umbraco-cms/backoffice/resources").UmbApiResponse<{
+        data: unknown;
+        request: Request;
+        response: Response;
+    }>>;
+    /**
+     * @param id guid id of the pipeline to retrieve results for
+     * @returns results (if there are any) for the pipeline
+     */
+    getResults(id: string): Promise<import("@umbraco-cms/backoffice/resources").UmbApiResponse<{
+        data: import("..").ProcessingResults;
+        request: Request;
+        response: Response;
+    }>>;
+    listPiplelines(status: PipelineStatus): Promise<import("@umbraco-cms/backoffice/resources").UmbApiResponse<{
+        data: import("..").Pipeline[];
+        request: Request;
+        response: Response;
+    }>>;
+}

package/dist/pipeline/pipeline.source.js

@@ -0,0 +1,79 @@
+import { tryExecute } from '@umbraco-cms/backoffice/resources';
+import { PipelinesService } from '../api';
+export class PipelineSource {
+    constructor(host) {
+        this.host = host;
+    }
+    async process(id, clientId) {
+        const result = await tryExecute(this.host, PipelinesService.processPipeline({
+            path: { id: id },
+            query: { clientId: clientId ?? undefined },
+        }));
+        return result;
+    }
+    /**
+     * @description re-registers a client id against a pipeline already running in the
+     * background (e.g. after a SignalR reconnect gave the browser a new connection id), and
+     * returns the full, current pipeline so the caller can resync rather than trust whatever it
+     * last saw down the old, now-dead connection.
+     */
+    async reattach(id, clientId) {
+        const result = await tryExecute(this.host, PipelinesService.reattachPipeline({
+            path: { id: id },
+            query: { clientId: clientId ?? undefined },
+        }));
+        return result;
+    }
+    async update(id, body) {
+        return await tryExecute(this.host, PipelinesService.updatePipeline({
+            path: { id: id },
+            body: body,
+        }));
+    }
+    async getProcessors() {
+        return await tryExecute(this.host, PipelinesService.getProcessors());
+    }
+    /**
+     *
+     * @param id guid id of the pipeline to retrieve
+     * @returns pipeline
+     */
+    async Get(id) {
+        return await tryExecute(this.host, PipelinesService.getPipeline({ path: { id: id } }));
+    }
+    /**
+     *
+     * @param strategy alias of the strategy to use for the pipeline
+     * @returns
+     */
+    async create(processor, strategy, options) {
+        return await tryExecute(this.host, PipelinesService.createPipeline({
+            body: {
+                alias: processor,
+                strategy: strategy,
+                options: options,
+                clientId: null,
+            },
+        }));
+    }
+    /**
+     *
+     * @param id guid id of the pipeline to remove
+     * @returns nothing.
+     */
+    async clear(id) {
+        return await tryExecute(this.host, PipelinesService.clearPipeline({ path: { id: id } }));
+    }
+    /**
+     * @param id guid id of the pipeline to retrieve results for
+     * @returns results (if there are any) for the pipeline
+     */
+    async getResults(id) {
+        return await tryExecute(this.host, PipelinesService.getResults({
+            path: { id: id },
+        }));
+    }
+    async listPiplelines(status) {
+        return await tryExecute(this.host, PipelinesService.listPipelines({ path: { status: status } }));
+    }
+}

package/dist/pipeline/pipelines.context.d.ts

@@ -0,0 +1,12 @@
+import { UmbControllerBase } from '@umbraco-cms/backoffice/class-api';
+import { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
+import { UmbContextToken } from '@umbraco-cms/backoffice/context-api';
+import { PipelineStatus } from '../api';
+export declare class PipelinesContext extends UmbControllerBase {
+    #private;
+    constructor(host: UmbControllerHost);
+    listPipelines(status: PipelineStatus): Promise<import("..").Pipeline[]>;
+    clear(id: string): Promise<unknown>;
+}
+export default PipelinesContext;
+export declare const JUMOO_PIPELINES_CONTEXT: UmbContextToken<PipelinesContext, PipelinesContext>;

package/dist/pipeline/pipelines.context.js

@@ -0,0 +1,33 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _PipelinesContext_repository;
+import { UmbControllerBase } from '@umbraco-cms/backoffice/class-api';
+import { PipelineRepository } from './pipeline.repository';
+import { UmbContextToken } from '@umbraco-cms/backoffice/context-api';
+export class PipelinesContext extends UmbControllerBase {
+    constructor(host) {
+        super(host);
+        _PipelinesContext_repository.set(this, void 0);
+        __classPrivateFieldSet(this, _PipelinesContext_repository, new PipelineRepository(host), "f");
+        this.provideContext(JUMOO_PIPELINES_CONTEXT, this);
+    }
+    async listPipelines(status) {
+        const pipelines = await __classPrivateFieldGet(this, _PipelinesContext_repository, "f").listPipelines(status);
+        return pipelines;
+    }
+    async clear(id) {
+        return await __classPrivateFieldGet(this, _PipelinesContext_repository, "f").clear(id);
+    }
+}
+_PipelinesContext_repository = new WeakMap();
+export default PipelinesContext;
+export const JUMOO_PIPELINES_CONTEXT = new UmbContextToken('JUMOO_PIPELINES_CONTEXT');

package/dist/pipeline/steps/index.d.ts

@@ -0,0 +1,2 @@
+export * from './interfaces.js';
+export * from './models.js';

package/dist/pipeline/steps/index.js

@@ -0,0 +1,2 @@
+export * from './interfaces.js';
+export * from './models.js';

package/dist/pipeline/steps/interfaces.d.ts

@@ -0,0 +1,10 @@
+import { ManifestElement } from '@umbraco-cms/backoffice/extension-api';
+import { ProcessStepElement } from '@jumoo/processing';
+export interface ManifestProcessStep extends ManifestElement<ProcessStepElement> {
+    type: 'jumoo-process-step';
+}
+declare global {
+    interface UmbExtensionManifestMap {
+        ManifestProcessStep: ManifestProcessStep;
+    }
+}

package/dist/pipeline/steps/interfaces.js

@@ -0,0 +1 @@
+export {};

package/dist/pipeline/steps/models.d.ts

@@ -0,0 +1,14 @@
+import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
+import { PipelineState, ProcessingOptions, ProcessingResults } from '@jumoo/processing';
+export declare class ProcessStepElement extends HTMLElement {
+    pipelineId: string | null | undefined;
+    state: PipelineState | null | undefined;
+    options: ProcessingOptions | null | undefined;
+    results: ProcessingResults | null | undefined;
+}
+export declare class ProcessStepElementBase extends UmbLitElement {
+    pipelineId: string | null | undefined;
+    state: PipelineState | null | undefined;
+    options: ProcessingOptions | null | undefined;
+    results: ProcessingResults | null | undefined;
+}

package/dist/pipeline/steps/models.js

@@ -0,0 +1,24 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
+import { property } from '@umbraco-cms/backoffice/external/lit';
+export class ProcessStepElement extends HTMLElement {
+}
+export class ProcessStepElementBase extends UmbLitElement {
+}
+__decorate([
+    property({ type: String })
+], ProcessStepElementBase.prototype, "pipelineId", void 0);
+__decorate([
+    property({ type: Object })
+], ProcessStepElementBase.prototype, "state", void 0);
+__decorate([
+    property({ type: Object })
+], ProcessStepElementBase.prototype, "options", void 0);
+__decorate([
+    property({ type: Object })
+], ProcessStepElementBase.prototype, "results", void 0);

package/dist/pipeline/workspace/manifest.d.ts

@@ -0,0 +1 @@
+export declare const manifests: import("@umbraco-cms/backoffice/extension-api").ManifestBase[];

package/dist/pipeline/workspace/manifest.js

@@ -0,0 +1,33 @@
+import { JUMOO_PROCESSING_PIPELINE_ENTITY_TYPE, JUMOO_PROCESSING_PIPELINE_WORKSPACE_ALIAS, } from './types.js';
+const workspace = {
+    type: 'workspace',
+    kind: 'routable',
+    alias: JUMOO_PROCESSING_PIPELINE_WORKSPACE_ALIAS,
+    name: 'Processing pipeline workspace',
+    api: () => import('./pipeline-workspace.context.js'),
+    meta: {
+        entityType: JUMOO_PROCESSING_PIPELINE_ENTITY_TYPE,
+    },
+};
+const viewConditions = [
+    {
+        alias: 'Umb.Condition.WorkspaceAlias',
+        match: JUMOO_PROCESSING_PIPELINE_WORKSPACE_ALIAS,
+    },
+];
+const views = [
+    {
+        type: 'workspaceView',
+        alias: 'jumoo-processing-pipeline-workspace-default-view',
+        name: 'Processing pipeline workspace default view',
+        js: () => import('./views/default-pipeline-view.js'),
+        weight: 300,
+        meta: {
+            label: 'Pipeline',
+            pathname: 'pipeline',
+            icon: 'icon-stack',
+        },
+        conditions: viewConditions,
+    },
+];
+export const manifests = [workspace, ...views];

package/dist/pipeline/workspace/pipeline-workspace.context.d.ts

@@ -0,0 +1,17 @@
+import { UmbEditableWorkspaceContextBase, UmbRoutableWorkspaceContext } from '@umbraco-cms/backoffice/workspace';
+import { Pipeline } from '../../api';
+import { UmbContextToken } from '@umbraco-cms/backoffice/context-api';
+import { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
+export declare class JumooProcessingPipelineWorkspaceContext extends UmbEditableWorkspaceContextBase<Pipeline> implements UmbRoutableWorkspaceContext {
+    #private;
+    readonly data: import("rxjs").Observable<Pipeline | undefined>;
+    readonly unique: import("rxjs").Observable<string | undefined>;
+    constructor(host: UmbControllerHost);
+    load(unique: string): Promise<void>;
+    getUnique(): string | null | undefined;
+    getEntityType(): string;
+    getData(): Pipeline | undefined;
+    protected submit(): Promise<void>;
+}
+export { JumooProcessingPipelineWorkspaceContext as api };
+export declare const JUMOO_PROCESSING_PIPELINE_WORKSPACE: UmbContextToken<JumooProcessingPipelineWorkspaceContext, JumooProcessingPipelineWorkspaceContext>;