@camunda/task-testing 2.2.0 → 3.0.0-0

package/dist/types/ElementConfig.d.ts

@@ -10,23 +10,26 @@ export class ElementConfig extends EventEmitter<[never]> {
     _injector: any;
     _elementVariables: any;
     /**
-     * @type {import('./types').Config}
+     * @type {Config}
      */
-    _config: import("./types").Config;
+    _config: Config;
     _selectedElement: any;
     _variablesForElements: Map<any, any>;
     setConfig(newConfig: any): void;
-    getConfig(): import("./types").Config;
+    getConfig(): Config;
     setInputConfigForElement(element: any, newConfig: any): void;
     resetInputConfigForElement(element: any): void;
     setOutputConfigForElement(element: any, newConfig: any): void;
     resetOutputConfigForElement(element: any): void;
     getInputConfigForElement(element: any): string;
     /**
-     * @param {import('./types').Element} element
-     * @returns {import('./types').ElementOutput}
+     * @param {Element} element
+     * @returns {ElementOutput}
      */
-    getOutputConfigForElement(element: import("./types").Element): import("./types").ElementOutput;
+    getOutputConfigForElement(element: Element): ElementOutput;
     _getDefaultInputConfig(): string;
 }
 import EventEmitter from 'events';
+import type { Config } from './types';
+import type { Element } from './types';
+import type { ElementOutput } from './types';

package/dist/types/ExecutionLog.d.ts

@@ -0,0 +1,196 @@
+export function createJobEntry(item: any, timestamp: any, overrides: any): {
+    type: "job";
+    data: ExecutionLogJobData;
+    timestamp: any;
+};
+/**
+ * Create log entries from job items. When a job has both a creation time
+ * (present for jobs created after 8.9) and an end time, two entries are
+ * produced - one for when the job was created and one for when it reached its
+ * final state (completed, failed, etc.). When a job has no creation time, the
+ * matching element instance's startDate is used as a best approximation.
+ *
+ * @param {JobSearchResult[]} jobs
+ * @param {ElementInstanceResult[]} elementInstances
+ * @param {number} fallbackTimestamp
+ *
+ * @returns {ExecutionLogJobEntry[]}
+ */
+export function createJobEntries(jobs: JobSearchResult[], elementInstances: ElementInstanceResult[], fallbackTimestamp: number): ExecutionLogJobEntry[];
+/**
+ * Create log entries from user task items. When a task has both a creation date
+ * and a completion date, two entries are produced — one for when the task was
+ * created and one for when it was completed.
+ *
+ * @param {UserTaskResult[]} userTasks
+ * @param {number} fallbackTimestamp
+ *
+ * @returns {ExecutionLogUserTaskEntry[]}
+ */
+export function createUserTaskEntries(userTasks: UserTaskResult[], fallbackTimestamp: number): ExecutionLogUserTaskEntry[];
+/**
+ * Create log entries from element instance items. When an instance has both a
+ * start date and an end date, two entries are produced — one for when the
+ * instance became active and one for when it completed.
+ *
+ * @param {ElementInstanceResult[]} instances
+ * @param {number} fallbackTimestamp
+ *
+ * @returns {ExecutionLogElementInstanceEntry[]}
+ */
+export function createElementInstanceEntries(instances: ElementInstanceResult[], fallbackTimestamp: number): ExecutionLogElementInstanceEntry[];
+/**
+ * Create log entries for message subscriptions. Timestamps are resolved from
+ * the matching element instance's startDate, since message subscriptions are
+ * created when their element is entered. Falls back to the poll timestamp
+ * when no matching element instance is found.
+ *
+ * @param {any[]} subscriptions
+ * @param {any[]} elementInstances
+ * @param {number} fallbackTimestamp
+ *
+ * @returns {ExecutionLogMessageSubscriptionEntry[]}
+ */
+export function createMessageSubscriptionEntries(subscriptions: any[], elementInstances: any[], fallbackTimestamp: number): ExecutionLogMessageSubscriptionEntry[];
+/**
+ * Create a status entry from a finished execution result.
+ *
+ * @param {TaskExecutionFinishedResult} result
+ * @param {number} timestamp
+ *
+ * @returns {ExecutionLogStatusEntry}
+ */
+export function createFinishedStatusEntry(result: TaskExecutionFinishedResult, timestamp: number): ExecutionLogStatusEntry;
+/**
+ * Format an element type for display (e.g. SERVICE_TASK → "Service Task").
+ *
+ * @param {string} type
+ *
+ * @returns {string}
+ */
+export function formatElementType(type: string): string;
+export namespace EXECUTION_LOG_ENTRY_TYPE {
+    let STATUS: "status";
+    let JOB: "job";
+    let USER_TASK: "user-task";
+    let MESSAGE_SUBSCRIPTION: "message-subscription";
+    let ELEMENT_INSTANCE: "element-instance";
+}
+export namespace EXECUTION_LOG_ENTRY_STATUS {
+    let DEPLOYING: "deploying";
+    let DEPLOYED: "deployed";
+    let STARTING_INSTANCE: "starting-instance";
+    let INSTANCE_STARTED: "instance-started";
+    let EXECUTING: "executing";
+    let COMPLETED: "completed";
+    let INCIDENT: "incident";
+    let TERMINATED: "terminated";
+    let CANCELED: "canceled";
+}
+export default class ExecutionLog {
+    /**
+     * @param {Injector} [injector]
+     */
+    constructor(injector?: Injector);
+    /** @type {{ type: TaskExecutionState, timestamp: number }|null} */
+    _state: {
+        type: TaskExecutionState;
+        timestamp: number;
+    } | null;
+    /** @type {{ response: DeployResponse, timestamp: number }|null} */
+    _deployResponse: {
+        response: DeployResponse;
+        timestamp: number;
+    } | null;
+    /** @type {{ response: StartInstanceResponse, timestamp: number }|null} */
+    _startInstanceResponse: {
+        response: StartInstanceResponse;
+        timestamp: number;
+    } | null;
+    /** @type {{
+     *   result: TaskExecutionPolledResult;
+     *   timestamp: number;
+     * }|null} */
+    _polledResult: {
+        result: TaskExecutionPolledResult;
+        timestamp: number;
+    } | null;
+    /** @type {{
+     *   result: TaskExecutionFinishedResult;
+     *   timestamp: number;
+     * }|null} */
+    _finishedResult: {
+        result: TaskExecutionFinishedResult;
+        timestamp: number;
+    } | null;
+    /** @type {ExecutionLogEntry[]} */
+    _entries: ExecutionLogEntry[];
+    /** @type {Object|null} */
+    _elementRegistry: any | null;
+    /**
+     * Set state.
+     *
+     * @param {TaskExecutionState} state
+     * @param {number} [timestamp]
+     */
+    setState(state: TaskExecutionState, timestamp?: number): void;
+    /**
+     * Set deploy response.
+     *
+     * @param {DeployResponse} deployResponse
+     * @param {number} [timestamp]
+     */
+    setDeployResponse(deployResponse: DeployResponse, timestamp?: number): void;
+    /**
+     * Set start instance response.
+     *
+     * @param {StartInstanceResponse} startInstanceResponse
+     * @param {number} [timestamp]
+     */
+    setStartInstanceResponse(startInstanceResponse: StartInstanceResponse, timestamp?: number): void;
+    /**
+     * Set poll result.
+     *
+     * @param {TaskExecutionPolledResult} result
+     * @param {number} [timestamp]
+     */
+    setPolledResult(result: TaskExecutionPolledResult, timestamp?: number): void;
+    /**
+     * Set finished result.
+     *
+     * @param {TaskExecutionFinishedResult} result
+     * @param {number} [timestamp]
+     */
+    setFinishedResult(result: TaskExecutionFinishedResult, timestamp?: number): void;
+    /**
+     * @returns {ExecutionLogEntry[]}
+     */
+    getEntries(): ExecutionLogEntry[];
+    /**
+     * Clear all data and entries.
+     */
+    reset(): void;
+    /**
+     * Build the full list of log entries from all available data. Entries are
+     * compiled from deploy/start-instance responses, polled result items (jobs,
+     * user tasks, element instances, message subscriptions), the finished result,
+     * and the ephemeral execution state. All entries are sorted chronologically.
+     */
+    _updateEntries(): void;
+}
+import type { ExecutionLogJobData } from './types';
+import type { JobSearchResult } from './types';
+import type { ElementInstanceResult } from './types';
+import type { ExecutionLogJobEntry } from './types';
+import type { UserTaskResult } from './types';
+import type { ExecutionLogUserTaskEntry } from './types';
+import type { ExecutionLogElementInstanceEntry } from './types';
+import type { ExecutionLogMessageSubscriptionEntry } from './types';
+import type { TaskExecutionFinishedResult } from './types';
+import type { ExecutionLogStatusEntry } from './types';
+import type { TaskExecutionState } from './types';
+import type { DeployResponse } from './types';
+import type { StartInstanceResponse } from './types';
+import type { TaskExecutionPolledResult } from './types';
+import type { ExecutionLogEntry } from './types';
+import type { Injector } from 'didi';

package/dist/types/TaskExecution.d.ts

@@ -1,67 +1,133 @@
 /**
+ * Get the incident details from the response.
  *
- * @param {import('./types').VariableSearchResult[]} getVariablesResponseItems
- * @param {import('./types').ElementInstanceResult[]} getElementInstancesResponseItems
- * @param {import('./types').ProcessInstanceResult} processInstance
- * @param elementId
- * @returns {object}
+ * @param {IncidentSearchQueryResult} response
+ *
+ * @returns {IncidentResult|null}
  */
-export function getVariables(getVariablesResponseItems: import("./types").VariableSearchResult[], getElementInstancesResponseItems: import("./types").ElementInstanceResult[], processInstance: import("./types").ProcessInstanceResult, elementId: any): object;
+export function getIncident(response: IncidentSearchQueryResult): IncidentResult | null;
 /**
  * Get the process definition key from the deployment response.
  *
- * @param {import('./types').ExtendedDeploymentResult} deployResponse
+ * @param {DeploymentResult} deployResponse
  * @param {string} processId
  *
- * @returns {string | null}
+ * @returns {string|null} The process definition key or null if not found.
  */
-export function getProcessDefinitionKey(deployResponse: import("./types").ExtendedDeploymentResult, processId: string): string | null;
-export const INTERVAL_MS: 1000;
-export namespace SCOPES {
-    let LOCAL: string;
-    let PROCESS: string;
+export function getProcessDefinitionKey(deployResponse: DeploymentResult, processId: string): string | null;
+/**
+ * Get the element instance of the given element from the response.
+ *
+ * @param {ElementInstanceSearchQueryResult} response
+ * @param {Element} element
+ *
+ * @returns {ElementInstanceResult|null} The element instance or null if not found.
+ */
+export function getElementInstance(response: ElementInstanceSearchQueryResult, element: Element): ElementInstanceResult | null;
+export const POLL_INTERVAL_MS: 1000;
+export namespace TASK_EXECUTION_STATE {
+    let IDLE: "idle";
+    let DEPLOYING: "deploying";
+    let STARTING_INSTANCE: "starting-instance";
+    let EXECUTING: "executing";
+}
+export namespace TASK_EXECUTION_FINISHED_REASON {
+    let ERROR: "error";
+    let INCIDENT: "incident";
+    let TERMINATED: "terminated";
+    let USER_CANCEL: "user.cancel";
+    let USER_SELECTION_CHANGED: "user.selectionChanged";
+}
+export namespace PROCESS_INSTANCE_STATE {
+    export let ACTIVE: "ACTIVE";
+    export let COMPLETED: "COMPLETED";
+    let TERMINATED_1: "TERMINATED";
+    export { TERMINATED_1 as TERMINATED };
+}
+export namespace ELEMENT_INSTANCE_STATE {
+    let ACTIVE_1: "ACTIVE";
+    export { ACTIVE_1 as ACTIVE };
+    let COMPLETED_1: "COMPLETED";
+    export { COMPLETED_1 as COMPLETED };
+    let TERMINATED_2: "TERMINATED";
+    export { TERMINATED_2 as TERMINATED };
+}
+export namespace TASK_EXECUTION_EVENT {
+    let STATE_CHANGED: "taskExecution.state.changed";
+    let DEPLOYED: "taskExecution.deployed";
+    let INSTANCE_STARTED: "taskExecution.instanceStarted";
+    let POLLED: "taskExecution.polled";
+    let FINISHED: "taskExecution.finished";
 }
 /**
- * Emits:
- * - `taskExecution.status.changed` with one of {@link TaskExecutionStatus}
- * - `taskExecution.finished` with {@link TaskExecutionResult}
- * - `taskExecution.error` with {@link TaskExecutionError}
- * - `taskExecution.interrupted` when execution is interrupted by switching focus
+ * Deploys a process, starts an instance, and polls for completion every second.
+ * Each call to {@link executeTask} assigns a unique execution ID; in-flight
+ * responses from a superseded or canceled execution are silently discarded.
+ *
+ * Cancellation {@link cancelTaskExecution} (user-initiated, selection change, or error) clears the interval,
+ * invalidates the execution ID, and emits a finished event. Process instances
+ * are not automatically terminated on cancellation.
+ *
+ * @emits `taskExecution.state.changed` with payload of type {@link TaskExecutionState}
+ * @emits `taskExecution.deployed` with payload of type {@link DeploymentResult}
+ * @emits `taskExecution.instanceStarted` with payload of type {@link CreateProcessInstanceResult}
+ * @emits `taskExecution.polled` with payload of type {@link TaskExecutionPolledResult}
+ * @emits `taskExecution.finished` with payload of type {@link TaskExecutionFinishedResult}
  */
 export default class TaskExecution extends EventEmitter<[never]> {
     /**
-     * @param {import('didi').Injector} injector
+     * @param {Injector} injector
      * @param {TaskExecutionApi} api
      */
-    constructor(injector: import("didi").Injector, api: TaskExecutionApi);
+    constructor(injector: Injector, api: TaskExecutionApi);
     /** @type {TaskExecutionApi} */
     _api: TaskExecutionApi;
     _interval: NodeJS.Timeout | null;
-    /** @type {TaskExecutionStatus} */
-    _status: TaskExecutionStatus;
+    /** @type {Symbol|null} */
+    _executionId: Symbol | null;
+    /** @type {typeof TASK_EXECUTION_STATE[keyof typeof TASK_EXECUTION_STATE]} */
+    _state: (typeof TASK_EXECUTION_STATE)[keyof typeof TASK_EXECUTION_STATE];
+    /** @type {TaskExecutionPolledResult|null} */
+    _lastPolledResult: TaskExecutionPolledResult | null;
     /**
-     * Start task execution.
+     * Start task execution. If an execution is already in progress, its
+     * in-flight responses will be silently discarded.
      *
-     * @param {import('./types').Element} element
+     * @param {Element} element
      * @param {Object} variables
      *
      * @returns {Promise<void>}
      */
-    executeTask(element: import("./types").Element, variables: any): Promise<void>;
+    executeTask(element: Element, variables: any): Promise<void>;
     /**
-     * Cancel current task execution, clean up and change status to `idle`.
+     * Cancel current task execution with user cancellation reason.
      */
     cancelTaskExecution(): Promise<void>;
     /**
-     * Emit `taskExecution.error` event.
+     * Cancel current task execution, invalidate the execution ID, and
+     * transition to idle. No-op when already idle. If a reason is provided,
+     * emits a `taskExecution.finished` event with the corresponding result.
+     *
+     * @param {typeof TASK_EXECUTION_FINISHED_REASON[keyof typeof TASK_EXECUTION_FINISHED_REASON]} [reason]
+     * @param {TaskExecutionError} [error]
+     */
+    _cancelTaskExecution(reason?: (typeof TASK_EXECUTION_FINISHED_REASON)[keyof typeof TASK_EXECUTION_FINISHED_REASON], error?: TaskExecutionError): void;
+    /**
+     * Change execution state and emit event.
      *
-     * @param {string} message
-     * @param {any} [response]
+     * @param {typeof TASK_EXECUTION_STATE[keyof typeof TASK_EXECUTION_STATE]} state - New state
      */
-    _emitError(message: string, response?: any): void;
-    /** @param {TaskExecutionStatus} status */
-    _changeStatus(status: TaskExecutionStatus, ...args: any[]): void;
+    _changeState(state: (typeof TASK_EXECUTION_STATE)[keyof typeof TASK_EXECUTION_STATE]): void;
+    _isIdle(): boolean;
 }
+import type { IncidentSearchQueryResult } from './types';
+import type { IncidentResult } from './types';
+import type { DeploymentResult } from './types';
+import type { ElementInstanceSearchQueryResult } from './types';
+import type { Element } from './types';
+import type { ElementInstanceResult } from './types';
 import EventEmitter from 'events';
 import type { TaskExecutionApi } from './types';
-import type { TaskExecutionStatus } from './types';
+import type { TaskExecutionPolledResult } from './types';
+import type { TaskExecutionError } from './types';
+import type { Injector } from 'didi';

package/dist/types/components/Input/InputEditor.d.ts

@@ -1,7 +1,8 @@
-export default function InputEditor({ allOutputs, value, onChange, onErrorChange, variablesForElement }: {
+export default function InputEditor({ allOutputs, value, onChange, onClear, onErrorChange, variablesForElement }: {
     allOutputs?: {} | undefined;
     value: any;
     onChange: any;
+    onClear: any;
     onErrorChange: any;
     variablesForElement?: any[] | undefined;
 }): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/Output/ExecutionLog.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @param {Object} props
+ * @param {ExecutionLogEntry[]} props.entries
+ * @param {string} [props.tasklistBaseUrl]
+ * @param {string|null} [props.currentOperateUrl]
+ * @param {boolean} [props.isTaskExecuting]
+ */
+export function ExecutionLog({ entries, tasklistBaseUrl, currentOperateUrl, isTaskExecuting }: {
+    entries: ExecutionLogEntry[];
+    tasklistBaseUrl?: string | undefined;
+    currentOperateUrl?: string | null | undefined;
+    isTaskExecuting?: boolean | undefined;
+}): import("react/jsx-runtime").JSX.Element;
+export namespace JOB_STATES {
+    let CANCELED: "CANCELED";
+    let COMPLETED: "COMPLETED";
+    let CREATED: "CREATED";
+    let ERROR_THROWN: "ERROR_THROWN";
+    let FAILED: "FAILED";
+    let MIGRATED: "MIGRATED";
+    let RETRIES_UPDATED: "RETRIES_UPDATED";
+    let TIMED_OUT: "TIMED_OUT";
+}
+import type { ExecutionLogEntry } from '../../types';

package/dist/types/components/Output/Output.d.ts

@@ -1,46 +1,43 @@
 /**
  * @param {Object} props
- * @param {import('bpmn-js/lib/model/Types').Element} props.element
+ * @param {Element} props.element
  * @param {boolean} props.isConnectionConfigured
- * @param {string} props.configureConnectionBannerTitle
- * @param {string} props.configureConnectionBannerDescription
- * @param {string} props.configureConnectionLabel
- * @param {string|undefined} props.currentOperateUrl
- * @param {Function} [props.onConfigureConnection]
+ * @param {string|null} props.currentOperateUrl
  * @param {boolean} props.isTaskExecuting
- * @param {import('../../types').ElementOutput} props.output
+ * @param {ElementOutput} props.output
  * @param {Function} props.onResetOutput
- * @param {import('../../types').TaskExecutionStatus} props.taskExecutionStatus
+ * @param {TaskExecutionState} props.taskExecutionState
+ * @param {ExecutionLogEntry[]} props.executionLog
+ * @param {string} [props.tasklistBaseUrl]
+ * @param {Object} [props.currentVariables]
  */
-export default function Output({ element, isConnectionConfigured, configureConnectionBannerTitle, configureConnectionBannerDescription, configureConnectionLabel, onConfigureConnection, isTaskExecuting, output, currentOperateUrl, onResetOutput, taskExecutionStatus }: {
-    element: import("bpmn-js/lib/model/Types").Element;
+export default function Output({ element, isConnectionConfigured, isTaskExecuting, output, currentOperateUrl, onResetOutput, taskExecutionState, executionLog, tasklistBaseUrl, currentVariables }: {
+    element: Element;
     isConnectionConfigured: boolean;
-    configureConnectionBannerTitle: string;
-    configureConnectionBannerDescription: string;
-    configureConnectionLabel: string;
-    currentOperateUrl: string | undefined;
-    onConfigureConnection?: Function | undefined;
+    currentOperateUrl: string | null;
     isTaskExecuting: boolean;
-    output: import("../../types").ElementOutput;
+    output: ElementOutput;
     onResetOutput: Function;
-    taskExecutionStatus: import("../../types").TaskExecutionStatus;
+    taskExecutionState: TaskExecutionState;
+    executionLog: ExecutionLogEntry[];
+    tasklistBaseUrl?: string | undefined;
+    currentVariables?: any;
 }): import("react/jsx-runtime").JSX.Element;
-export const TASK_EXECUTION_STATUS_LABEL: {
-    deploying: string;
-    'starting-instance': string;
-    executing: string;
-};
-export const NO_OPERATE_URL_TOOLTIP: "No Operate URL set for this connection";
-export function HeaderLink({ children, render, visible, href, target, className, onClick, role, tooltip, priority }: {
-    render?: ((props: any) => React.ReactNode) | undefined;
-    children?: React.ReactNode;
-    visible?: boolean | ((props: any) => boolean) | undefined;
-    href?: string | ((props: any) => string) | undefined;
-    target?: string | ((props: any) => string) | undefined;
-    className?: string | ((props: any) => string | undefined) | undefined;
-    onClick?: Function | ((props: any) => Function) | undefined;
-    role?: string | ((props: any) => string) | undefined;
-    tooltip?: string | ((props: any) => string | undefined) | undefined;
+export function HeaderLink({ children, render, visible, href, target, className, onClick, renderIcon, role, tooltip, priority }: {
+    children?: null | undefined;
+    render?: ((props?: any) => React.ReactNode) | undefined;
+    visible: any;
+    href: any;
+    target: any;
+    className: any;
+    onClick?: undefined;
+    renderIcon: any;
+    role?: undefined;
+    tooltip: any;
     priority?: number | undefined;
 }): null;
+import type { Element } from 'bpmn-js/lib/model/Types';
+import type { ElementOutput } from '../../types';
+import type { TaskExecutionState } from '../../types';
+import type { ExecutionLogEntry } from '../../types';
 import React from 'react';

package/dist/types/components/TaskTesting/TaskTesting.d.ts

@@ -1,49 +1,58 @@
 /**
  * @param {Object} props
  * @param {Object} props.injector
- * @param {import('../../types').TaskExecutionApi} props.api
+ * @param {TaskExecutionApi} props.api
  * @param {boolean} props.isConnectionConfigured
  * @param {string} [props.configureConnectionBannerTitle]
  * @param {string} [props.configureConnectionBannerDescription]
  * @param {string} [props.configureConnectionLabel]
  * @param {Function} [props.onConfigureConnection] - Callback invoked when
  * the user clicks on the _Configure connection_ button.
- * @param {(() => boolean | Promise<boolean>)} [props.onTestTask] - Callback invoked when the user clicks
- * on the _Test task_ button. Should return `true` to proceed with task
- * execution or `false` to abort it. Can return a promise resolving to a
- * boolean.
- * @param {import('../../types').Config|undefined} [props.config]
- * @param {Function} [props.onConfigChanged=() => {}]
+ * @param {(() => boolean | Promise<boolean>)} [props.onTestTask] - Callback
+ * invoked when the user clicks on the _Test task_ button. Should return `true`
+ * to proceed with task execution or `false` to abort it. Can return a promise
+ * resolving to a boolean.
+ * @param {Config|undefined} [props.config]
+ * @param {(config: Config) => void} [props.onConfigChanged] - Called when the configuration changes
  * @param {string} [props.operateBaseUrl]
+ * @param {string} [props.tasklistBaseUrl]
  * @param {string} [props.documentationUrl]
- * @param {Function} [props.onTaskExecutionStarted=() => {}]
- * @param {Function} [props.onTaskExecutionFinished=() => {}]
- * @param {Function} [props.onTaskExecutionInterrupted=() => {}]
+ * @param {(element: Element) => void} [props.onTaskExecutionStarted] - Called with (element) when task execution starts
+ * @param {(element: Element, result: TaskExecutionFinishedResult) => void} [props.onTaskExecutionFinished] - Called with (element, result) where result contains success and optional reason for failures
  * @param {React.ReactNode[]} [props.children=[]]
  */
-declare function TaskTesting({ injector, api, isConnectionConfigured, configureConnectionBannerTitle, configureConnectionBannerDescription, configureConnectionLabel, onConfigureConnection, onTestTask, config, onConfigChanged, operateBaseUrl, documentationUrl, onTaskExecutionStarted, onTaskExecutionFinished, onTaskExecutionInterrupted, children }: {
+declare function TaskTesting({ injector, api, isConnectionConfigured, configureConnectionBannerTitle, configureConnectionBannerDescription, configureConnectionLabel, onConfigureConnection, onTestTask, config, onConfigChanged, operateBaseUrl, tasklistBaseUrl, documentationUrl, onTaskExecutionStarted, onTaskExecutionFinished, children }: {
     injector: any;
-    api: import("../../types").TaskExecutionApi;
+    api: TaskExecutionApi;
     isConnectionConfigured: boolean;
     configureConnectionBannerTitle?: string | undefined;
     configureConnectionBannerDescription?: string | undefined;
     configureConnectionLabel?: string | undefined;
     onConfigureConnection?: Function | undefined;
     onTestTask?: (() => boolean | Promise<boolean>) | undefined;
-    config?: import("../../types").Config | undefined;
-    onConfigChanged?: Function | undefined;
+    config?: Config | undefined;
+    onConfigChanged?: ((config: Config) => void) | undefined;
     operateBaseUrl?: string | undefined;
+    tasklistBaseUrl?: string | undefined;
     documentationUrl?: string | undefined;
-    onTaskExecutionStarted?: Function | undefined;
-    onTaskExecutionFinished?: Function | undefined;
-    onTaskExecutionInterrupted?: Function | undefined;
+    onTaskExecutionStarted?: ((element: Element) => void) | undefined;
+    onTaskExecutionFinished?: ((element: Element, result: TaskExecutionFinishedResult) => void) | undefined;
     children?: React.ReactNode[] | undefined;
 }): import("react/jsx-runtime").JSX.Element;
 declare namespace TaskTesting {
-    export { OutputTab as Tab };
+    export { PluginTab as Tab };
     export { HeaderLink as Link };
 }
 export default TaskTesting;
+import type { TaskExecutionApi } from '../../types';
+import type { Config } from '../../types';
+import type { Element } from 'bpmn-js/lib/model/Types';
+import type { TaskExecutionFinishedResult } from '../../types';
 import React from 'react';
-import { OutputTab } from '../Output/OutputVariables';
+declare function PluginTab({ children, render, label, priority }: {
+    children?: null | undefined;
+    render?: (() => null) | undefined;
+    label: any;
+    priority?: number | undefined;
+}): null;
 import { HeaderLink } from '../Output/Output';

package/dist/types/components/shared/Tooltip.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @typedef {'bottom-start' | 'bottom-end' | 'top-start' | 'top-end'} TooltipAlign
+ */
+/**
+ * Lightweight tooltip component.
+ *
+ * @param {Object} props
+ * @param {React.ReactNode} props.label - Tooltip content
+ * @param {React.ReactNode} props.children - Trigger element(s)
+ * @param {TooltipAlign} [props.align='bottom-start'] - Tooltip alignment
+ * @param {string} [props.className] - Additional CSS class for the wrapper
+ * @param {number} [props.showDelay=250] - Delay in ms before showing
+ * @param {number} [props.hideDelay=250] - Delay in ms before hiding
+ */
+export default function Tooltip({ label, children, align, className, showDelay, hideDelay }: {
+    label: React.ReactNode;
+    children: React.ReactNode;
+    align?: TooltipAlign | undefined;
+    className?: string | undefined;
+    showDelay?: number | undefined;
+    hideDelay?: number | undefined;
+}): import("react/jsx-runtime").JSX.Element;
+export type TooltipAlign = "bottom-start" | "bottom-end" | "top-start" | "top-end";
+import React from 'react';

package/dist/types/components/shared/plugins.d.ts

@@ -1,4 +1,4 @@
-export const PluginContext: import("react").Context<import("../../types").PluginContextValue>;
+export const PluginContext: import("react").Context<PluginContextValue>;
 export function usePluginsProviderValue(defaultValue?: Plugin[]): PluginContextValue;
-export type Plugin = import("../../types").Plugin;
-export type PluginContextValue = import("../../types").PluginContextValue;
+import type { PluginContextValue } from '../../types';
+import type { Plugin } from '../../types';

package/dist/types/hooks/useSelectedElement.d.ts

@@ -1,11 +1,13 @@
 /**
- * Get currently selected BPMN element, if it is a single `bpmn:Task`. If not,
- * return null and a message indicating what to do.
+ * Get currently selected BPMN element, if it is a single supported element
+ * (`bpmn:Task` or `bpmn:SubProcess`). If not, return null and a message
+ * indicating what to do.
  *
  * @param {Object} injector
- * @return {[ Object|null, string|null ]}
+ *
+ * @returns {[ Object|null, string|null ]}
  */
 export function useSelectedElement(injector: any): [any | null, string | null];
-export const SINGLE_TASK_SELECTION_REQUIRED_MESSAGE: "Select a task to start testing.";
-export const TASK_SELECTION_REQUIRED_MESSAGE: "Task testing is only supported for tasks. Select a task to start testing.";
-export const AD_HOC_SUBPROCESS_TASK_UNSUPPORTED_MESSAGE: "Task testing is not supported for tasks inside an ad-hoc subprocess. Select a different task to start testing.";
+export const SINGLE_TASK_SELECTION_REQUIRED_MESSAGE: "Select a task or subprocess to start testing.";
+export const TASK_SELECTION_REQUIRED_MESSAGE: "Task testing is only supported for tasks and subprocesses. Select one to start testing.";
+export const AD_HOC_SUBPROCESS_MESSAGE: "Task testing is not supported for tasks inside ad-hoc subprocesses.";