@szjy/workflow 0.1.0 → 0.1.3

package/dist/packages/components/Workflow/components/common/EditItem.vue.d.ts

@@ -0,0 +1,39 @@
+declare const _default: import("vue").DefineComponent<{
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    textAlign: {
+        type: StringConstructor;
+        default: string;
+        validator: (val: string) => boolean;
+    };
+    labelWidth: {
+        type: NumberConstructor;
+        default: number;
+    };
+}, unknown, unknown, {
+    labelStyle(): {
+        width: string;
+        textAlign: "center";
+    };
+}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    textAlign: {
+        type: StringConstructor;
+        default: string;
+        validator: (val: string) => boolean;
+    };
+    labelWidth: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>>, {
+    label: string;
+    labelWidth: number;
+    textAlign: string;
+}, {}>;
+export default _default;

package/dist/packages/components/Workflow/contants.d.ts

@@ -0,0 +1,31 @@
+import type { GetValuesFromArray } from "./types/utils";
+export declare const ACTIVIT_PREFIX = "activiti";
+export declare const LISTEN_TYPE_OPTIONS: import("vue").Ref<({
+    label: string;
+    value: "class";
+} | {
+    label: string;
+    value: "expression";
+} | {
+    label: string;
+    value: "delegateExpression";
+} | {
+    label: string;
+    value: "script";
+})[]>;
+export type ListenerTypeLiteral = GetValuesFromArray<typeof LISTEN_TYPE_OPTIONS.value, 'value'>;
+export declare const SCRIPT_TYPE_OPTIONS: import("vue").Ref<({
+    label: string;
+    value: "external";
+} | {
+    label: string;
+    value: "inline";
+} | {
+    label: string;
+    value: "none";
+})[]>;
+export type ScriptTypeLiteral = GetValuesFromArray<typeof SCRIPT_TYPE_OPTIONS.value, 'value'>;
+export declare const LISTENER_ALLOWED_TYPES: string[];
+export declare const USER_ASSIGN_PROP_KEYS: readonly ["assignee", "candidateUsers", "candidateGroups", "dueDate", "followUpDate", "priority"];
+export declare const MULTIINSTANCE_PROP_KEYS: readonly ["loopCardinality", "completionCondition", "collection", "elementVariable"];
+export declare const IMPLEMENTATION_PROP_KEYS: readonly ["", "class", "expression", "delegateExpression", "dmn", "external", "connector", "resultVariable"];

package/dist/packages/components/Workflow/customTranslate/index.d.ts

@@ -0,0 +1 @@
+export declare function customTranslate(template: string, replacements?: Record<string, string>): string;

package/dist/packages/components/Workflow/exposeApi.d.ts

@@ -0,0 +1,14 @@
+export declare const getWorkflowXml: () => Promise<string | undefined>;
+export declare function getPermissionJSON(): {
+    createFieldPermission: {
+        assigneeFieldPermissionMap: {
+            [key: string]: "EDITABLE" | "READ_ONLY" | "HIDDEN";
+        };
+        othersFieldPermissionMap: {
+            [key: string]: "EDITABLE" | "READ_ONLY" | "HIDDEN";
+        };
+    };
+    taskToFieldPermissionMap: any;
+};
+export declare function initXmlToStore(xml: string): Promise<void>;
+export declare function updateProcessId(processId: string): void;

package/dist/packages/components/Workflow/index.vue.d.ts

@@ -0,0 +1,13 @@
+import { getPermissionJSON, initXmlToStore, updateProcessId } from "./exposeApi";
+import BpmnModeler from 'bpmn-js/lib/Modeler.js';
+declare const _default: import("vue").DefineComponent<{}, {
+    getWorkflowXml: () => Promise<string | undefined>;
+    getPermissionJSON: typeof getPermissionJSON;
+    initXmlToStore: typeof initXmlToStore;
+    updateProcessId: typeof updateProcessId;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    init: (modeler: BpmnModeler) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{}>> & {
+    onInit?: ((modeler: BpmnModeler) => any) | undefined;
+}, {}, {}>;
+export default _default;

package/dist/packages/components/Workflow/main.vue.d.ts

@@ -0,0 +1,25 @@
+import { PropType } from 'vue';
+import BpmnModeler from 'bpmn-js/lib/Modeler.js';
+import 'bpmn-js/dist/assets/diagram-js.css';
+import 'bpmn-js/dist/assets/bpmn-font/css/bpmn.css';
+import 'bpmn-js/dist/assets/bpmn-font/css/bpmn-codes.css';
+import 'bpmn-js/dist/assets/bpmn-font/css/bpmn-embedded.css';
+import 'bpmn-js-properties-panel/dist/assets/properties-panel.css';
+declare const _default: import("vue").DefineComponent<{
+    label: {
+        type: PropType<string>;
+        default: string;
+    };
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "modeler-init": (modeler: BpmnModeler) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    label: {
+        type: PropType<string>;
+        default: string;
+    };
+}>> & {
+    "onModeler-init"?: ((modeler: BpmnModeler) => any) | undefined;
+}, {
+    label: string;
+}, {}>;
+export default _default;

package/dist/packages/components/Workflow/palette/CustomPalette.d.ts

@@ -0,0 +1,13 @@
+export declare function escapeCSS(str: string): string;
+/**
+ * A palette containing modeling elements.
+ *
+ * @param {EventBus} eventBus
+ * @param {Canvas} canvas
+ */
+declare function Palette(this: any, eventBus: any, canvas: any, elementFactory: any, create: any, paletteContainer: any, paletteEntries: any): void;
+declare namespace Palette {
+    var $inject: string[];
+    var HTML_MARKUP: string;
+}
+export default Palette;

package/dist/packages/components/Workflow/palette/CustomPaletteProvider.d.ts

@@ -0,0 +1,103 @@
+import PaletteProvider from "bpmn-js/lib/features/palette/PaletteProvider";
+import type BpmnSpaceTool from 'bpmn-js/lib/features/space-tool/BpmnSpaceTool';
+import type ElementFactory from 'diagram-js/lib/core/ElementFactory';
+import type Create from 'diagram-js/lib/features/create/Create';
+import type GlobalConnect from 'diagram-js/lib/features/global-connect/GlobalConnect';
+import type HandTool from 'diagram-js/lib/features/hand-tool/HandTool';
+import type LassoTool from 'diagram-js/lib/features/lasso-tool/LassoTool';
+import type Palette from 'diagram-js/lib/features/palette/Palette';
+import type { TranslateReplacements } from 'diagram-js/lib/i18n/translate/translate';
+import type { Connection, Label, Root, Shape } from 'diagram-js/lib/model/Types';
+export default class CustomPaletteProvider extends PaletteProvider {
+    create: Create;
+    elementFactory: ElementFactory<Connection, Label, Root, Shape>;
+    translate: (template: string, replacements?: TranslateReplacements | undefined) => string;
+    constructor(create: Create, elementFactory: ElementFactory<Connection, Label, Root, Shape>, globalConnect: GlobalConnect, handTool: HandTool, lassoTool: LassoTool, palette: Palette, spaceTool: BpmnSpaceTool, translate: (template: string, replacements?: TranslateReplacements | undefined) => string);
+    getPaletteEntries(): import("diagram-js/lib/features/palette/PaletteProvider").PaletteEntries & {
+        "set-workflow-status": {
+            group: string;
+            title: string;
+            imageUrl: any;
+            action: {
+                click: (event: any) => void;
+                dragstart: (event: any) => void;
+            };
+        };
+        "leave-gateway": {
+            group: string;
+            title: string;
+            imageUrl: any;
+            action: {
+                click: (event: any) => void;
+                dragstart: (event: any) => void;
+            };
+        };
+        "approval-user": {
+            group: string;
+            title: string;
+            imageUrl: any;
+            action: {
+                click: (event: any) => void;
+                dragstart: (event: any) => void;
+            };
+        };
+        "counter-sign-user": {
+            group: string;
+            title: string;
+            imageUrl: any;
+            action: {
+                click: (event: any) => void;
+                dragstart: (event: any) => void;
+            };
+        };
+        "get-multi-user": {
+            group: string;
+            title: string;
+            imageUrl: any;
+            action: {
+                click: (event: any) => void;
+                dragstart: (event: any) => void;
+            };
+        };
+        "get-single-user": {
+            group: string;
+            title: string;
+            imageUrl: any;
+            action: {
+                click: (event: any) => void;
+                dragstart: (event: any) => void;
+            };
+        };
+        "get-user-info": {
+            group: string;
+            title: string;
+            imageUrl: any;
+            action: {
+                click: (event: any) => void;
+                dragstart: (event: any) => void;
+            };
+        };
+        "get-supervisory-org": {
+            group: string;
+            title: string;
+            imageUrl: any;
+            action: {
+                click: (event: any) => void;
+                dragstart: (event: any) => void;
+            };
+        };
+        "get-company": {
+            group: string;
+            title: string;
+            imageUrl: any;
+            action: {
+                click: (event: any) => void;
+                dragstart: (event: any) => void;
+            };
+        };
+        'activity-separator': {
+            group: string;
+            separator: boolean;
+        };
+    };
+}

package/dist/packages/components/Workflow/palette/index.d.ts

@@ -0,0 +1,11 @@
+import customPalette from './CustomPalette';
+import PaletteProvider from './CustomPaletteProvider';
+declare const _default: {
+    __depends__: {
+        __init__: string[];
+        palette: (string | typeof customPalette)[];
+    }[];
+    __init__: string[];
+    paletteProvider: (string | typeof PaletteProvider)[];
+};
+export default _default;

package/dist/packages/components/Workflow/palette/replaceDefault.d.ts

@@ -0,0 +1 @@
+export declare const replaceDefaultPalette: () => void;

package/dist/packages/components/Workflow/store/bpmn-utils/FieldInjectionPropertiesUtil.d.ts

@@ -0,0 +1,10 @@
+import type { Element, ModdleElement } from 'bpmn-js/lib/model/Types';
+export declare function getFieldInjectionProperties(element: Element): ModdleElement[];
+export declare function addFieldInParent(element: Element, parent: ModdleElement, property: FieldPropertyForm): void;
+export declare function removeAllFieldInParent(element: Element, parent: ModdleElement): void;
+export declare function addFieldProperty(element: Element, property: FieldPropertyForm): void;
+export declare function removeFieldInjectionProperty(element: Element, property: ModdleElement): void;
+export declare function updateField(element: Element, property: ModdleElement, props: FieldPropertyForm): void;
+export declare function canFieldInjectable(element: Element): boolean;
+export declare function updateFieldProperty(element: Element, field: ModdleElement, props: FieldPropertyForm): void;
+export declare const toFormStyle: (field: BpmnFieldProperty) => FieldPropertyForm;

package/dist/packages/components/Workflow/store/bpmn-utils/asynchronousContinuationsUtil.d.ts

@@ -0,0 +1,8 @@
+import type { Element } from 'bpmn-js/lib/model/Types';
+export declare function getACBefore(element: Element): boolean;
+export declare function setACBefore(element: Element, value: boolean): void;
+export declare function getACAfter(element: Element): boolean;
+export declare function setACAfter(element: Element, value: boolean): void;
+export declare function getACExclusive(element: Element): boolean;
+export declare function setACExclusive(element: Element, value: boolean): void;
+export declare function isAsynchronous(element: Element): boolean;

package/dist/packages/components/Workflow/store/bpmn-utils/candidateStarter.d.ts

@@ -0,0 +1,6 @@
+import type { Element } from 'bpmn-js/lib/model/Types';
+export declare function getCandidateStarterGroups(element: Element): string | undefined;
+export declare function setCandidateStarterGroups(element: Element, value: string | undefined): void;
+export declare function getCandidateStarterUsers(element: Element): string | undefined;
+export declare function setCandidateStarterUsers(element: Element, value: string | undefined): void;
+export declare function hasCandidateStarter(element: Element): boolean;

package/dist/packages/components/Workflow/store/bpmn-utils/conditionUtil.d.ts

@@ -0,0 +1,27 @@
+import type { Element } from 'bpmn-js/lib/model/Types';
+import type { LiteralFromArray } from '../../types/utils';
+declare const CONDITIONAL_SOURCES: readonly ["bpmn:Activity", "bpmn:ExclusiveGateway", "bpmn:InclusiveGateway", "bpmn:ComplexGateway"];
+export type ConditionNodeType = LiteralFromArray<typeof CONDITIONAL_SOURCES>;
+export declare function isConditionalSource(element: Element): boolean;
+export declare function isSomeConditional(element: Element, type: ConditionNodeType): boolean;
+export declare function isConditionEventDefinition(element: Element): boolean;
+export declare function isExtendStartEvent(element: Element): boolean;
+export declare function isCanbeConditional(element: Element): boolean;
+export declare function getVariableNameValue(element: Element): string | undefined;
+export declare function setVariableNameValue(element: Element, value: string | undefined): void;
+export declare function getVariableEventsValue(element: Element): string | undefined;
+export declare function setVariableEventsValue(element: Element, value: string | undefined): void;
+export declare function getConditionTypeValue(element: Element): string;
+export declare function setConditionTypeValue(element: Element, value: string): void;
+export declare function getConditionExpressionValue(element: Element): string | undefined;
+export declare function setConditionExpressionValue(element: Element, body: string | undefined): void;
+export declare function getConditionScriptTypeValue(element: Element): string | undefined;
+export declare function setConditionScriptTypeValue(element: Element, value: string | undefined): void;
+export declare function getConditionScriptLanguageValue(element: Element): string | undefined;
+export declare function setConditionScriptLanguageValue(element: Element, value: string | undefined): void;
+export declare function getConditionScriptBodyValue(element: Element): string | undefined;
+export declare function setConditionScriptBodyValue(element: Element, value: string | undefined): void;
+export declare function getConditionScriptResourceValue(element: Element): string | undefined;
+export declare function setConditionScriptResourceValue(element: Element, value: string | undefined): void;
+export declare function getConditionTypeOptions(element: Element): Record<string, string>[];
+export {};

package/dist/packages/components/Workflow/store/bpmn-utils/documentationUtil.d.ts

@@ -0,0 +1,3 @@
+import type { Element } from 'bpmn-js/lib/model/Types';
+export declare function getDocumentValue(element: Element | undefined): string;
+export declare function setDocumentValue(element: Element, value: string | undefined): void;

package/dist/packages/components/Workflow/store/bpmn-utils/executionListenersUtil.d.ts

@@ -0,0 +1,14 @@
+import type { Element, ModdleElement } from 'bpmn-js/lib/model/Types';
+export declare function getExecutionListeners(element: Element): ModdleElement[];
+export declare function addEmptyExtensionListener(element: Element): void;
+export declare function addExecutionListener(element: Element, props: ExecutionListenerForm): void;
+export declare function updateExecutionListener(element: Element, props: ExecutionListenerForm, listener: ModdleElement): void;
+export declare function removeExecutionListener(element: Element, listener: ModdleElement): void;
+export declare function isExecutable(element: Element): boolean;
+export declare function getExecutionListenerType(listener: ModdleElement): string;
+export declare function getListenersContainer(element: Element): ModdleElement;
+export declare function getDefaultEvent(element: Element): "take" | "start";
+export declare function getExecutionListenerTypes(element: Element): {
+    label: string;
+    value: string;
+}[];

package/dist/packages/components/Workflow/store/bpmn-utils/extensionPropertiesUtil.d.ts

@@ -0,0 +1,4 @@
+import type { Element, ModdleElement } from 'bpmn-js/lib/model/Types';
+export declare function getExtensionProperties(element: Element): ModdleElement[];
+export declare function addExtensionProperty(element: Element, property: Record<string, any>): void;
+export declare function removeExtensionProperty(element: Element, property: ModdleElement): void;

package/dist/packages/components/Workflow/store/bpmn-utils/formTypeUtil.d.ts

@@ -0,0 +1,4 @@
+import type { Element } from 'bpmn-js/lib/model/Types';
+export declare function getFormKey(element: Element): string | undefined;
+export declare function setFormKey(element: Element, value: string | undefined): void;
+export declare function isFormSupported(element: Element): boolean;

package/dist/packages/components/Workflow/store/bpmn-utils/idUtil.d.ts

@@ -0,0 +1,3 @@
+import type { Element } from 'bpmn-js/lib/model/Types';
+export declare function getIdValue(element: Element): string;
+export declare function setIdValue(element: Element, value: string): import("naive-ui").MessageReactive | undefined;

package/dist/packages/components/Workflow/store/bpmn-utils/implementationUtil.d.ts

@@ -0,0 +1,12 @@
+import type { Element } from 'bpmn-js/lib/model/Types';
+import { IMPLEMENTATION_PROP_KEYS } from '../../contants';
+import type { LiteralFromArray } from '../../types/utils';
+export type ImplementationProp = LiteralFromArray<typeof IMPLEMENTATION_PROP_KEYS>;
+export declare const getTypeOptions: (element: Element) => {
+    value: string;
+    label: string;
+}[];
+export declare const setImplementationType: (element: Element, value: string) => void;
+export declare function geImplementationPropValue<T>(element: Element, propKey: ImplementationProp): T;
+export declare function getAllImplementationProps(element: Element): Record<ImplementationProp, any>;
+export declare function setImplementationPropValue<T>(element: Element, propKey: ImplementationProp, value: T): void;

package/dist/packages/components/Workflow/store/bpmn-utils/initiatorUtil.d.ts

@@ -0,0 +1,5 @@
+import type { Element } from 'bpmn-js/lib/model/Types';
+export declare function getInitiatorValue(element: Element): string | undefined;
+export declare function setInitiatorValue(element: Element, value: string | undefined): void;
+export declare function isStartInitializable(element: Element): boolean;
+export declare function isUserAssignmentSupported(element: Element): boolean;

package/dist/packages/components/Workflow/store/bpmn-utils/jobExecutionUtil.d.ts

@@ -0,0 +1,8 @@
+import type { Element } from 'bpmn-js/lib/model/Types';
+export declare function retryTimeCycleVisible(element: Element): boolean;
+export declare function taskPriorityVisible(element: Element): boolean;
+export declare function isJobExecutable(element: Element): boolean;
+export declare function getExternalTaskValue(element: Element): string | undefined;
+export declare function setExternalTaskValue(element: Element, value: string | undefined): void;
+export declare function getRetryTimeCycleValue(element: Element): string | undefined;
+export declare function setRetryTimeCycleValue(element: Element, value: string | undefined): void;

package/dist/packages/components/Workflow/store/bpmn-utils/listenersUtil.d.ts

@@ -0,0 +1,16 @@
+import type { Element, ModdleElement } from 'bpmn-js/lib/model/Types';
+export type ListenerElementType = 'TaskListener' | 'ExecutionListener';
+export declare function getListenersByType(element: Element, elementType: ListenerElementType): ModdleElement[];
+export declare function addEmptyExtensionListener(element: Element, elementType: ListenerElementType): void;
+export declare function addListenerByType(element: Element, props: ListenerForm, elementType: ListenerElementType): void;
+export declare function updateListenerByType(element: Element, props: ListenerForm, listener: ModdleElement, elementType: ListenerElementType): void;
+export declare function removeListenerByType(element: Element, listener: ModdleElement): void;
+export declare function hasTaskListeners(element: Element): boolean;
+export declare function isExecutable(element: Element): boolean;
+export declare function getListenerType(listener: ModdleElement, elementType: ListenerElementType): string;
+export declare function getListenersContainer(element: Element): ModdleElement;
+export declare function getListenerTypesOptions(element: Element, elementType: ListenerElementType): {
+    label: string;
+    value: string;
+}[];
+export declare function getDefaultEvent(element: Element, elementType: ListenerElementType): "create" | "take" | "start";

package/dist/packages/components/Workflow/store/bpmn-utils/multiInstanceUtil.d.ts

@@ -0,0 +1,8 @@
+import type { Element } from 'bpmn-js/lib/model/Types';
+import { MULTIINSTANCE_PROP_KEYS } from '../../contants';
+import type { LiteralFromArray } from '../../types/utils';
+export type MultiInstanceProp = LiteralFromArray<typeof MULTIINSTANCE_PROP_KEYS>;
+export declare function getMultiInstancePropValue<T>(element: Element, propKey: MultiInstanceProp): T;
+export declare function getAllMultiInstanceProps(element: Element): Record<MultiInstanceProp, any>;
+export declare function setMultiInstancePropValue<T>(element: Element, propKey: MultiInstanceProp, value: T): void;
+export declare function isMultiInstanceSupported(element: Element): boolean;

package/dist/packages/components/Workflow/store/bpmn-utils/nameUtil.d.ts

@@ -0,0 +1,3 @@
+import type { Element } from 'bpmn-js/lib/model/Types';
+export declare function getNameValue(element: Element): string | undefined;
+export declare function setNameValue(element: Element, value: string): void;

package/dist/packages/components/Workflow/store/bpmn-utils/processUtil.d.ts

@@ -0,0 +1,5 @@
+import type { Element } from 'bpmn-js/lib/model/Types';
+export declare function getProcessExecutable(element: Element): boolean;
+export declare function setProcessExecutable(element: Element, value: boolean): void;
+export declare function getProcessVersionTag(element: Element): string | undefined;
+export declare function setProcessVersionTag(element: Element, value: string): void;

package/dist/packages/components/Workflow/store/bpmn-utils/scriptUtil.d.ts

@@ -0,0 +1,3 @@
+import type { ModdleElement } from 'bpmn-js/lib/model/Types';
+export declare function createScript(props: ScriptForm): ModdleElement;
+export declare function getScriptType(script: ModdleElement & BpmnScript): string;

package/dist/packages/components/Workflow/store/bpmn-utils/userAssignmentUtil.d.ts

@@ -0,0 +1,8 @@
+import type { Element } from 'bpmn-js/lib/model/Types';
+import { USER_ASSIGN_PROP_KEYS } from '../../contants';
+import type { LiteralFromArray } from '../../types/utils';
+export type UserAssigneeProp = LiteralFromArray<typeof USER_ASSIGN_PROP_KEYS>;
+export declare function getUserAssignPropValue<T>(element: Element, propKey: UserAssigneeProp): T;
+export declare function getAllUserAssignProps(element: Element): Record<UserAssigneeProp, any>;
+export declare function setUserAssignPropValue<T>(element: Element, propKey: UserAssigneeProp, value: T): void;
+export declare function isUserAssignmentSupported(element: Element): boolean;

package/dist/packages/components/Workflow/store/instance.d.ts

@@ -0,0 +1 @@
+export declare const piniaInstance: import("pinia").Pinia;

package/dist/packages/components/Workflow/store/modeler.d.ts

@@ -0,0 +1,69 @@
+import type Modeler from 'bpmn-js/lib/Modeler';
+import type Modeling from 'bpmn-js/lib/features/modeling/Modeling';
+import type Canvas from 'diagram-js/lib/core/Canvas';
+import type { Element } from 'bpmn-js/lib/model/Types';
+declare const useModelerStore: import("pinia").StoreDefinition<"modeler", import("pinia")._UnwrapAll<Pick<{
+    modeler: import("vue").ShallowRef<Modeler | undefined>;
+    moddle: import("vue").ShallowRef<any>;
+    modeling: import("vue").ShallowRef<Modeling<import("bpmn-js/lib/model/Types").Connection, Element, import("bpmn-js/lib/model/Types").Label, import("bpmn-js/lib/model/Types").Parent, import("bpmn-js/lib/model/Types").Shape> | undefined>;
+    canvas: import("vue").ShallowRef<Canvas | undefined>;
+    elementRegistry: import("vue").Ref<{
+        add: (element: import("diagram-js/lib/model/Types").ElementLike, gfx: SVGElement, secondaryGfx?: SVGElement | undefined) => void;
+        remove: (element: string | import("diagram-js/lib/model/Types").ElementLike) => void;
+        updateId: (element: string | import("diagram-js/lib/model/Types").ElementLike, newId: string) => void;
+        updateGraphics: (filter: string | import("diagram-js/lib/model/Types").ElementLike, gfx: SVGElement, secondary?: boolean | undefined) => SVGElement;
+        get: (filter: string | SVGElement) => import("diagram-js/lib/model/Types").ElementLike | undefined;
+        filter: (fn: import("diagram-js/lib/core/ElementRegistry").ElementRegistryFilterCallback) => import("diagram-js/lib/model/Types").ElementLike[];
+        find: (fn: import("diagram-js/lib/core/ElementRegistry").ElementRegistryFilterCallback) => import("diagram-js/lib/model/Types").ElementLike | undefined;
+        getAll: () => import("diagram-js/lib/model/Types").ElementLike[];
+        forEach: (fn: import("diagram-js/lib/core/ElementRegistry").ElementRegistryForEachCallback) => void;
+        getGraphics: (filter: string | import("diagram-js/lib/model/Types").ElementLike, secondary?: boolean | undefined) => SVGElement;
+    } | undefined>;
+    activeElement: import("vue").ShallowRef<Element | undefined>;
+    activeElementId: import("vue").Ref<string | undefined>;
+    setModeler: (modelerInput: Modeler | undefined) => void;
+    setElement: (element: Element | undefined) => void;
+}, "modeler" | "moddle" | "modeling" | "canvas" | "elementRegistry" | "activeElement" | "activeElementId">>, Pick<{
+    modeler: import("vue").ShallowRef<Modeler | undefined>;
+    moddle: import("vue").ShallowRef<any>;
+    modeling: import("vue").ShallowRef<Modeling<import("bpmn-js/lib/model/Types").Connection, Element, import("bpmn-js/lib/model/Types").Label, import("bpmn-js/lib/model/Types").Parent, import("bpmn-js/lib/model/Types").Shape> | undefined>;
+    canvas: import("vue").ShallowRef<Canvas | undefined>;
+    elementRegistry: import("vue").Ref<{
+        add: (element: import("diagram-js/lib/model/Types").ElementLike, gfx: SVGElement, secondaryGfx?: SVGElement | undefined) => void;
+        remove: (element: string | import("diagram-js/lib/model/Types").ElementLike) => void;
+        updateId: (element: string | import("diagram-js/lib/model/Types").ElementLike, newId: string) => void;
+        updateGraphics: (filter: string | import("diagram-js/lib/model/Types").ElementLike, gfx: SVGElement, secondary?: boolean | undefined) => SVGElement;
+        get: (filter: string | SVGElement) => import("diagram-js/lib/model/Types").ElementLike | undefined;
+        filter: (fn: import("diagram-js/lib/core/ElementRegistry").ElementRegistryFilterCallback) => import("diagram-js/lib/model/Types").ElementLike[];
+        find: (fn: import("diagram-js/lib/core/ElementRegistry").ElementRegistryFilterCallback) => import("diagram-js/lib/model/Types").ElementLike | undefined;
+        getAll: () => import("diagram-js/lib/model/Types").ElementLike[];
+        forEach: (fn: import("diagram-js/lib/core/ElementRegistry").ElementRegistryForEachCallback) => void;
+        getGraphics: (filter: string | import("diagram-js/lib/model/Types").ElementLike, secondary?: boolean | undefined) => SVGElement;
+    } | undefined>;
+    activeElement: import("vue").ShallowRef<Element | undefined>;
+    activeElementId: import("vue").Ref<string | undefined>;
+    setModeler: (modelerInput: Modeler | undefined) => void;
+    setElement: (element: Element | undefined) => void;
+}, never>, Pick<{
+    modeler: import("vue").ShallowRef<Modeler | undefined>;
+    moddle: import("vue").ShallowRef<any>;
+    modeling: import("vue").ShallowRef<Modeling<import("bpmn-js/lib/model/Types").Connection, Element, import("bpmn-js/lib/model/Types").Label, import("bpmn-js/lib/model/Types").Parent, import("bpmn-js/lib/model/Types").Shape> | undefined>;
+    canvas: import("vue").ShallowRef<Canvas | undefined>;
+    elementRegistry: import("vue").Ref<{
+        add: (element: import("diagram-js/lib/model/Types").ElementLike, gfx: SVGElement, secondaryGfx?: SVGElement | undefined) => void;
+        remove: (element: string | import("diagram-js/lib/model/Types").ElementLike) => void;
+        updateId: (element: string | import("diagram-js/lib/model/Types").ElementLike, newId: string) => void;
+        updateGraphics: (filter: string | import("diagram-js/lib/model/Types").ElementLike, gfx: SVGElement, secondary?: boolean | undefined) => SVGElement;
+        get: (filter: string | SVGElement) => import("diagram-js/lib/model/Types").ElementLike | undefined;
+        filter: (fn: import("diagram-js/lib/core/ElementRegistry").ElementRegistryFilterCallback) => import("diagram-js/lib/model/Types").ElementLike[];
+        find: (fn: import("diagram-js/lib/core/ElementRegistry").ElementRegistryFilterCallback) => import("diagram-js/lib/model/Types").ElementLike | undefined;
+        getAll: () => import("diagram-js/lib/model/Types").ElementLike[];
+        forEach: (fn: import("diagram-js/lib/core/ElementRegistry").ElementRegistryForEachCallback) => void;
+        getGraphics: (filter: string | import("diagram-js/lib/model/Types").ElementLike, secondary?: boolean | undefined) => SVGElement;
+    } | undefined>;
+    activeElement: import("vue").ShallowRef<Element | undefined>;
+    activeElementId: import("vue").Ref<string | undefined>;
+    setModeler: (modelerInput: Modeler | undefined) => void;
+    setElement: (element: Element | undefined) => void;
+}, "setModeler" | "setElement">>;
+export default useModelerStore;

package/dist/packages/components/Workflow/store/permission/constants.d.ts

@@ -0,0 +1,41 @@
+export declare const PERMISSION_TYPE: {
+    readonly EDITABLE: "EDITABLE";
+    readonly READ_ONLY: "READ_ONLY";
+    readonly HIDDEN: "HIDDEN";
+};
+export declare const ASSIGNEE_MAP_KEY = "assigneeFieldPermissionMap";
+export declare const OTHER_MAP_KEY = "othersFieldPermissionMap";
+export type PermissionGroupName = "assigneeFieldPermissionMap" | "othersFieldPermissionMap";
+export type PermissionType = keyof typeof PERMISSION_TYPE;
+export declare const CREATION_KEY = "createFieldPermission";
+export declare const EDITABLE_KEY = "taskToFieldPermissionMap";
+export declare const PERMISSION_OPTIONS: ({
+    label: string;
+    value: "EDITABLE";
+} | {
+    label: string;
+    value: "READ_ONLY";
+})[];
+export type TaskPermissionMap = {
+    [ASSIGNEE_MAP_KEY]: PermissionItem[];
+    [OTHER_MAP_KEY]: PermissionItem[];
+};
+export type AllTaskPermissionMap = {
+    [key: string]: TaskPermissionMap;
+};
+export type PermissionItem = {
+    key: string;
+    fieldName: string;
+    permission: PermissionType;
+};
+export declare const convertPermissionArrayToMap: (permissionArray?: PermissionItem[]) => {
+    [key: string]: "EDITABLE" | "READ_ONLY" | "HIDDEN";
+};
+export declare const convertTaskPermissionMapToMap: (taskPermissionMap: Partial<TaskPermissionMap>) => {
+    assigneeFieldPermissionMap: {
+        [key: string]: "EDITABLE" | "READ_ONLY" | "HIDDEN";
+    };
+    othersFieldPermissionMap: {
+        [key: string]: "EDITABLE" | "READ_ONLY" | "HIDDEN";
+    };
+};

package/dist/packages/components/Workflow/store/permission/index.d.ts

@@ -0,0 +1,27 @@
+import { type AllTaskPermissionMap, type PermissionGroupName, type PermissionType, type TaskPermissionMap } from './constants';
+declare const usePermissionStore: import("pinia").StoreDefinition<"permission", import("pinia")._UnwrapAll<Pick<{
+    creationMap: import("vue").ShallowRef<Partial<TaskPermissionMap>>;
+    setCreationMap: (map: Partial<TaskPermissionMap>) => void;
+    allNodesMap: import("vue").Ref<AllTaskPermissionMap>;
+    curNodeId: import("vue").Ref<string>;
+    setCurNodeId: (id?: string) => void;
+    curNodeMap: import("vue").ComputedRef<TaskPermissionMap>;
+    updateFieldPermission: (groupName: PermissionGroupName, idx: number, permission: PermissionType) => void;
+}, "creationMap" | "allNodesMap" | "curNodeId">>, Pick<{
+    creationMap: import("vue").ShallowRef<Partial<TaskPermissionMap>>;
+    setCreationMap: (map: Partial<TaskPermissionMap>) => void;
+    allNodesMap: import("vue").Ref<AllTaskPermissionMap>;
+    curNodeId: import("vue").Ref<string>;
+    setCurNodeId: (id?: string) => void;
+    curNodeMap: import("vue").ComputedRef<TaskPermissionMap>;
+    updateFieldPermission: (groupName: PermissionGroupName, idx: number, permission: PermissionType) => void;
+}, "curNodeMap">, Pick<{
+    creationMap: import("vue").ShallowRef<Partial<TaskPermissionMap>>;
+    setCreationMap: (map: Partial<TaskPermissionMap>) => void;
+    allNodesMap: import("vue").Ref<AllTaskPermissionMap>;
+    curNodeId: import("vue").Ref<string>;
+    setCurNodeId: (id?: string) => void;
+    curNodeMap: import("vue").ComputedRef<TaskPermissionMap>;
+    updateFieldPermission: (groupName: PermissionGroupName, idx: number, permission: PermissionType) => void;
+}, "setCreationMap" | "setCurNodeId" | "updateFieldPermission">>;
+export default usePermissionStore;

package/dist/packages/components/Workflow/store/useElementUpdateListener.d.ts

@@ -0,0 +1 @@
+export default function (listener: () => void): (() => void)[];

package/dist/packages/components/Workflow/types/utils.d.ts

@@ -0,0 +1,5 @@
+export type LiteralFromArray<T extends readonly any[]> = T[number];
+type GetElementType<T extends unknown[]> = T extends (infer U)[] ? U : never;
+type GetValue<T, U extends keyof T> = T[U];
+export type GetValuesFromArray<T extends any[], U extends string> = GetValue<GetElementType<T>, U>;
+export {};

package/dist/packages/components/Workflow/utils/BpmnAsyncElement.d.ts

@@ -0,0 +1,4 @@
+import type { ModdleElement } from 'bpmn-js/lib/model/Types';
+export declare function isAsyncBefore(bo: ModdleElement): boolean;
+export declare function isAsyncAfter(bo: ModdleElement): boolean;
+export declare function isAsync(bo: ModdleElement): boolean;