`moonrockz/diagrams/bpmn`

Types

`AssociationDirection`

pub(all) enum AssociationDirection {
  None
  One
  Both
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

`AssociationDirection::equal`

fn AssociationDirection::equal(AssociationDirection, AssociationDirection) -> Bool

Source

`AssociationDirection::not_equal`

fn AssociationDirection::not_equal(x : AssociationDirection, y : AssociationDirection) -> Bool

Source

`AssociationDirection::to_repr`

fn AssociationDirection::to_repr(AssociationDirection) -> @moonbitlang/core/debug.Repr

Source

`Bounds`

pub(all) struct Bounds {
  x : Int
  y : Int
  width : Int
  height : Int
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

`Bounds::equal`

fn Bounds::equal(Bounds, Bounds) -> Bool

Source

`Bounds::not_equal`

fn Bounds::not_equal(x : Bounds, y : Bounds) -> Bool

Source

`Bounds::to_repr`

fn Bounds::to_repr(Bounds) -> @moonbitlang/core/debug.Repr

Source

`Bpmn`

pub struct Bpmn {
  id : String
  label : String
  source : SourceIdentity
  kind : ViewKind
  plane : SourceIdentity?
  nodes : ReadOnlyArray[Node]
  flows : ReadOnlyArray[Flow]
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

`Bpmn::equal`

fn Bpmn::equal(Bpmn, Bpmn) -> Bool

Source

`Bpmn::new`

fn Bpmn::new(id : String, nodes : ArrayView[Node], flows : ArrayView[Flow], label? : String, source? : SourceIdentity, kind? : ViewKind, plane? : SourceIdentity) -> Bpmn

Source

`Bpmn::not_equal`

fn Bpmn::not_equal(x : Bpmn, y : Bpmn) -> Bool

Source

`Bpmn::scope`

fn Bpmn::scope(self : Bpmn, limits? : ScopeLimits) -> ScopeResult

Pure selected visibility shared by geometry, motion and structural queries. Group membership is visual grouping and never hides a member.

Source

`Bpmn::to_repr`

fn Bpmn::to_repr(Bpmn) -> @moonbitlang/core/debug.Repr

Source

`ConnectionKind`

pub(all) enum ConnectionKind {
  SequenceFlow
  MessageFlow
  Association
  DataInputAssociation
  DataOutputAssociation
  DataAssociation
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

`ConnectionKind::equal`

fn ConnectionKind::equal(ConnectionKind, ConnectionKind) -> Bool

Source

`ConnectionKind::not_equal`

fn ConnectionKind::not_equal(x : ConnectionKind, y : ConnectionKind) -> Bool

Source

`ConnectionKind::to_repr`

fn ConnectionKind::to_repr(ConnectionKind) -> @moonbitlang/core/debug.Repr

Source

`EdgeGeometry`

pub struct EdgeGeometry {
  identity : SourceIdentity
  points : ReadOnlyArray[ExactPoint]
  label : LabelGeometry?
  source_shape : SourceIdentity?
  target_shape : SourceIdentity?
  message_visible : MessageVisibility?
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

`EdgeGeometry::equal`

fn EdgeGeometry::equal(EdgeGeometry, EdgeGeometry) -> Bool

Source

`EdgeGeometry::new`

fn EdgeGeometry::new(identity : SourceIdentity, points : ArrayView[ExactPoint], label? : LabelGeometry, source_shape? : SourceIdentity, target_shape? : SourceIdentity, message_visible? : MessageVisibility) -> EdgeGeometry

Source

`EdgeGeometry::not_equal`

fn EdgeGeometry::not_equal(x : EdgeGeometry, y : EdgeGeometry) -> Bool

Source

`EdgeGeometry::to_repr`

fn EdgeGeometry::to_repr(EdgeGeometry) -> @moonbitlang/core/debug.Repr

Source

`EventKind`

pub(all) enum EventKind {
  Message
  Timer
  Conditional
  Link
  Signal
  Error
  Escalation
  Cancel
  Compensation
  Terminate
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

`EventKind::equal`

fn EventKind::equal(EventKind, EventKind) -> Bool

Source

`EventKind::not_equal`

fn EventKind::not_equal(x : EventKind, y : EventKind) -> Bool

Source

`EventKind::to_repr`

fn EventKind::to_repr(EventKind) -> @moonbitlang/core/debug.Repr

Source

`EventMarker`

pub struct EventMarker {
  kind : EventKind
  identity : SourceIdentity?
  settings : ReadOnlyArray[(String, String)]
} derive(Eq, @moonbitlang/core/debug.Debug)

Flattened semantic settings retain source expressions as text. These values describe a symbol; they are never evaluated as execution instructions.

Source

`EventMarker::equal`

fn EventMarker::equal(EventMarker, EventMarker) -> Bool

Source

`EventMarker::new`

fn EventMarker::new(kind : EventKind, identity? : SourceIdentity, settings? : ArrayView[(String, String)]) -> EventMarker

Source

`EventMarker::not_equal`

fn EventMarker::not_equal(x : EventMarker, y : EventMarker) -> Bool

Source

`EventMarker::to_repr`

fn EventMarker::to_repr(EventMarker) -> @moonbitlang/core/debug.Repr

Source

`ExactBounds`

pub struct ExactBounds {
  x : Number
  y : Number
  width : Number
  height : Number
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

`ExactBounds::equal`

fn ExactBounds::equal(ExactBounds, ExactBounds) -> Bool

Source

`ExactBounds::new`

fn ExactBounds::new(x : Number, y : Number, width : Number, height : Number) -> ExactBounds

Source

`ExactBounds::not_equal`

fn ExactBounds::not_equal(x : ExactBounds, y : ExactBounds) -> Bool

Source

`ExactBounds::to_repr`

fn ExactBounds::to_repr(ExactBounds) -> @moonbitlang/core/debug.Repr

Source

`ExactPoint`

pub struct ExactPoint {
  x : Number
  y : Number
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

`ExactPoint::equal`

fn ExactPoint::equal(ExactPoint, ExactPoint) -> Bool

Source

`ExactPoint::new`

fn ExactPoint::new(x : Number, y : Number) -> ExactPoint

Source

`ExactPoint::not_equal`

fn ExactPoint::not_equal(x : ExactPoint, y : ExactPoint) -> Bool

Source

`ExactPoint::to_repr`

fn ExactPoint::to_repr(ExactPoint) -> @moonbitlang/core/debug.Repr

Source

`Flow`

pub struct Flow {
  id : String
  identity : SourceIdentity
  kind : ConnectionKind
  source : String
  target : String
  has_source : Bool
  semantic_source : SourceIdentity?
  semantic_target : SourceIdentity
  points : ReadOnlyArray[Point]
  geometry : EdgeGeometry?
  label : String
  condition : String?
  is_default : Bool
  direction : AssociationDirection
  properties : RenderProperties?
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

`Flow::equal`

fn Flow::equal(Flow, Flow) -> Bool

Source

`Flow::new`

fn Flow::new(id : String, source : String, target : String, points? : ArrayView[Point], identity? : SourceIdentity, kind? : ConnectionKind, has_source? : Bool, semantic_source? : SourceIdentity, semantic_target? : SourceIdentity, geometry? : EdgeGeometry, label? : String, condition? : String, is_default? : Bool, direction? : AssociationDirection, properties? : RenderProperties) -> Flow

Source

`Flow::not_equal`

fn Flow::not_equal(x : Flow, y : Flow) -> Bool

Source

`Flow::to_repr`

fn Flow::to_repr(Flow) -> @moonbitlang/core/debug.Repr

Source

`Flow::with_properties`

fn Flow::with_properties(self : Flow, properties : RenderProperties) -> Flow

Source

`Font`

pub struct Font {
  name : String?
  size : Number?
  bold : Bool?
  italic : Bool?
  underline : Bool?
  strike_through : Bool?
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

`Font::equal`

fn Font::equal(Font, Font) -> Bool

Source

`Font::new`

fn Font::new(name? : String, size? : Number, bold? : Bool, italic? : Bool, underline? : Bool, strike_through? : Bool) -> Font

Source

`Font::not_equal`

fn Font::not_equal(x : Font, y : Font) -> Bool

Source

`Font::to_repr`

fn Font::to_repr(Font) -> @moonbitlang/core/debug.Repr

Source

`GeometryPolicy`

pub(all) enum GeometryPolicy {
  PreferDi
  RequireDi
  Automatic
} derive(Eq, @moonbitlang/core/debug.Debug)

Use one complete coordinate system for a selected BPMN view.

Source

`GeometryPolicy::equal`

fn GeometryPolicy::equal(GeometryPolicy, GeometryPolicy) -> Bool

Source

`GeometryPolicy::not_equal`

fn GeometryPolicy::not_equal(x : GeometryPolicy, y : GeometryPolicy) -> Bool

Source

`GeometryPolicy::to_repr`

fn GeometryPolicy::to_repr(GeometryPolicy) -> @moonbitlang/core/debug.Repr

Source

`LabelGeometry`

pub struct LabelGeometry {
  bounds : ExactBounds?
  style : SourceIdentity?
  font : Font?
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

`LabelGeometry::equal`

fn LabelGeometry::equal(LabelGeometry, LabelGeometry) -> Bool

Source

`LabelGeometry::new`

fn LabelGeometry::new(bounds? : ExactBounds, style? : SourceIdentity, font? : Font) -> LabelGeometry

Source

`LabelGeometry::not_equal`

fn LabelGeometry::not_equal(x : LabelGeometry, y : LabelGeometry) -> Bool

Source

`LabelGeometry::to_repr`

fn LabelGeometry::to_repr(LabelGeometry) -> @moonbitlang/core/debug.Repr

Source

`Link`

pub struct Link {
  target : String
} derive(Eq, @moonbitlang/core/debug.Debug)

Links are explicit caller-supplied metadata. Vendor XML never creates one.

Source

`Link::equal`

fn Link::equal(Link, Link) -> Bool

Source

`Link::new`

fn Link::new(target : String) -> Link

Source

`Link::not_equal`

fn Link::not_equal(x : Link, y : Link) -> Bool

Source

`Link::to_repr`

fn Link::to_repr(Link) -> @moonbitlang/core/debug.Repr

Source

`LoopKind`

pub(all) enum LoopKind {
  None
  Standard
  Sequential
  Parallel
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

`LoopKind::equal`

fn LoopKind::equal(LoopKind, LoopKind) -> Bool

Source

`LoopKind::not_equal`

fn LoopKind::not_equal(x : LoopKind, y : LoopKind) -> Bool

Source

`LoopKind::to_repr`

fn LoopKind::to_repr(LoopKind) -> @moonbitlang/core/debug.Repr

Source

`Markers`

pub struct Markers {
  loop_kind : LoopKind
  called_kind : NodeKind?
  called_element : SourceIdentity?
  compensation : Bool
  event_subprocess : Bool
  interrupting : Bool
  parallel_multiple : Bool
  collection : Bool
  instantiate : Bool
  events : ReadOnlyArray[EventMarker]
  details : ReadOnlyArray[(String, String)]
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

`Markers::equal`

fn Markers::equal(Markers, Markers) -> Bool

Source

`Markers::new`

fn Markers::new(loop_kind? : LoopKind, called_kind? : NodeKind, called_element? : SourceIdentity, compensation? : Bool, event_subprocess? : Bool, interrupting? : Bool, parallel_multiple? : Bool, collection? : Bool, instantiate? : Bool, events? : ArrayView[EventMarker], details? : ArrayView[(String, String)]) -> Markers

Source

`Markers::not_equal`

fn Markers::not_equal(x : Markers, y : Markers) -> Bool

Source

`Markers::to_repr`

fn Markers::to_repr(Markers) -> @moonbitlang/core/debug.Repr

Source

`MessageVisibility`

pub(all) enum MessageVisibility {
  Initiating
  NonInitiating
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

`MessageVisibility::equal`

fn MessageVisibility::equal(MessageVisibility, MessageVisibility) -> Bool

Source

`MessageVisibility::not_equal`

fn MessageVisibility::not_equal(x : MessageVisibility, y : MessageVisibility) -> Bool

Source

`MessageVisibility::to_repr`

fn MessageVisibility::to_repr(MessageVisibility) -> @moonbitlang/core/debug.Repr

Source

`Node`

pub struct Node {
  id : String
  source : SourceIdentity
  kind : NodeKind
  label : String
  bounds : Bounds
  geometry : ShapeGeometry?
  ownership : Ownership
  markers : Markers
  expanded : Bool?
  black_box : Bool
  properties : RenderProperties?
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

`Node::equal`

fn Node::equal(Node, Node) -> Bool

Source

`Node::new`

fn Node::new(id : String, kind : NodeKind, bounds? : Bounds, label? : String, source? : SourceIdentity, geometry? : ShapeGeometry, ownership? : Ownership, markers? : Markers, expanded? : Bool, black_box? : Bool, properties? : RenderProperties) -> Node

Integer bounds remain the thin-slice convenience input. Exact selected DI lives in geometry; absent geometry does not assert a zero-sized source shape.

Source

`Node::not_equal`

fn Node::not_equal(x : Node, y : Node) -> Bool

Source

`Node::to_repr`

fn Node::to_repr(Node) -> @moonbitlang/core/debug.Repr

Source

`Node::with_black_box`

fn Node::with_black_box(self : Node, black_box : Bool) -> Node

Source

`Node::with_ownership`

fn Node::with_ownership(self : Node, ownership : Ownership) -> Node

Source

`Node::with_properties`

fn Node::with_properties(self : Node, properties : RenderProperties) -> Node

Source

`NodeKind`

pub(all) enum NodeKind {
  StartEvent
  EndEvent
  IntermediateCatchEvent
  IntermediateThrowEvent
  BoundaryEvent
  Task
  UserTask
  ServiceTask
  SendTask
  ReceiveTask
  ManualTask
  BusinessRuleTask
  ScriptTask
  SubProcess
  AdHocSubProcess
  Transaction
  CallActivity
  ExclusiveGateway
  InclusiveGateway
  ParallelGateway
  ComplexGateway
  EventBasedGateway
  Participant
  Lane
  DataObject
  DataObjectReference
  DataStore
  DataStoreReference
  DataInput
  DataOutput
  Group
  TextAnnotation
  Message
} derive(Eq, @moonbitlang/core/debug.Debug)

Standard process/collaboration graphical kinds. Choreography and conversation remain document values and are explicitly deferred by the adapter.

Source

`NodeKind::equal`

fn NodeKind::equal(NodeKind, NodeKind) -> Bool

Source

`NodeKind::not_equal`

fn NodeKind::not_equal(x : NodeKind, y : NodeKind) -> Bool

Source

`NodeKind::to_repr`

fn NodeKind::to_repr(NodeKind) -> @moonbitlang/core/debug.Repr

Source

`Number`

pub struct Number {
  token : String
} derive(Eq, @moonbitlang/core/debug.Debug)

Exact finite XML numeric spelling. Renderers may approximate for measurements but must retain these tokens when drawing supplied geometry.

Source

`Number::equal`

fn Number::equal(Number, Number) -> Bool

Source

`Number::not_equal`

fn Number::not_equal(x : Number, y : Number) -> Bool

Source

`Number::parse`

fn Number::parse(token : String) -> Number?

Source

`Number::to_repr`

fn Number::to_repr(Number) -> @moonbitlang/core/debug.Repr

Source

`Ownership`

pub struct Ownership {
  pool : String?
  lanes : ReadOnlyArray[String]
  subprocess : String?
  attached_to : String?
  groups : ReadOnlyArray[String]
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

`Ownership::equal`

fn Ownership::equal(Ownership, Ownership) -> Bool

Source

`Ownership::new`

fn Ownership::new(pool? : String, lanes? : ArrayView[String], subprocess? : String, attached_to? : String, groups? : ArrayView[String]) -> Ownership

Source

`Ownership::not_equal`

fn Ownership::not_equal(x : Ownership, y : Ownership) -> Bool

Source

`Ownership::to_repr`

fn Ownership::to_repr(Ownership) -> @moonbitlang/core/debug.Repr

Source

`Point`

pub(all) struct Point {
  x : Int
  y : Int
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

`Point::equal`

fn Point::equal(Point, Point) -> Bool

Source

`Point::not_equal`

fn Point::not_equal(x : Point, y : Point) -> Bool

Source

`Point::to_repr`

fn Point::to_repr(Point) -> @moonbitlang/core/debug.Repr

Source

`RenderProperties`

pub struct RenderProperties {
  description : String?
  sublabel : String?
  link : Link?
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

`RenderProperties::equal`

fn RenderProperties::equal(RenderProperties, RenderProperties) -> Bool

Source

`RenderProperties::new`

fn RenderProperties::new(description? : String, sublabel? : String, link? : Link) -> RenderProperties

Source

`RenderProperties::not_equal`

fn RenderProperties::not_equal(x : RenderProperties, y : RenderProperties) -> Bool

Source

`RenderProperties::to_repr`

fn RenderProperties::to_repr(RenderProperties) -> @moonbitlang/core/debug.Repr

Source

`Scope`

pub struct Scope {
  view : Bpmn
  visible : ReadOnlyArray[Bool]
  containers : ReadOnlyArray[Int?]
  work : Int
  // private fields
}

Source

`Scope::node_index`

fn Scope::node_index(self : Scope, id : String) -> Int?

Source

`ScopeLimits`

pub struct ScopeLimits {
  nodes : Int
  work : Int
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

`ScopeLimits::equal`

fn ScopeLimits::equal(ScopeLimits, ScopeLimits) -> Bool

Source

`ScopeLimits::new`

fn ScopeLimits::new(nodes? : Int, work? : Int) -> ScopeLimits

Source

`ScopeLimits::not_equal`

fn ScopeLimits::not_equal(x : ScopeLimits, y : ScopeLimits) -> Bool

Source

`ScopeLimits::to_repr`

fn ScopeLimits::to_repr(ScopeLimits) -> @moonbitlang/core/debug.Repr

Source

`ScopeResult`

pub struct ScopeResult {
  scope : Scope?
  diagnostics : ReadOnlyArray[@moonrockz/diagrams.Diagnostic]
}

Source

`ShapeGeometry`

pub struct ShapeGeometry {
  identity : SourceIdentity
  bounds : ExactBounds?
  label : LabelGeometry?
  horizontal : Bool?
  expanded : Bool?
  marker_visible : Bool?
  message_visible : Bool?
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

`ShapeGeometry::equal`

fn ShapeGeometry::equal(ShapeGeometry, ShapeGeometry) -> Bool

Source

`ShapeGeometry::new`

fn ShapeGeometry::new(identity : SourceIdentity, bounds? : ExactBounds, label? : LabelGeometry, horizontal? : Bool, expanded? : Bool, marker_visible? : Bool, message_visible? : Bool) -> ShapeGeometry

Source

`ShapeGeometry::not_equal`

fn ShapeGeometry::not_equal(x : ShapeGeometry, y : ShapeGeometry) -> Bool

Source

`ShapeGeometry::to_repr`

fn ShapeGeometry::to_repr(ShapeGeometry) -> @moonbitlang/core/debug.Repr

Source

`SourceIdentity`

pub struct SourceIdentity {
  resource_id : String?
  source_id : String?
  path : ReadOnlyArray[Int]
} derive(Eq, @moonbitlang/core/debug.Debug)

The source identity is independent of the per-view render ID. Paths contain source-order child indices and survive absence of an XML ID.

Source

`SourceIdentity::equal`

fn SourceIdentity::equal(SourceIdentity, SourceIdentity) -> Bool

Source

`SourceIdentity::new`

fn SourceIdentity::new(source_id? : String, resource_id? : String, path? : ArrayView[Int]) -> SourceIdentity

Source

`SourceIdentity::not_equal`

fn SourceIdentity::not_equal(x : SourceIdentity, y : SourceIdentity) -> Bool

Source

`SourceIdentity::to_repr`

fn SourceIdentity::to_repr(SourceIdentity) -> @moonbitlang/core/debug.Repr

Source

`ViewKind`

pub(all) enum ViewKind {
  Process
  Collaboration
} derive(Eq, @moonbitlang/core/debug.Debug)

Source

`ViewKind::equal`

fn ViewKind::equal(ViewKind, ViewKind) -> Bool

Source

`ViewKind::not_equal`

fn ViewKind::not_equal(x : ViewKind, y : ViewKind) -> Bool

Source

`ViewKind::to_repr`

fn ViewKind::to_repr(ViewKind) -> @moonbitlang/core/debug.Repr

Source