šŸ„® mooncakes.io
    Sign in

    bpmn

    Portable BPMN document reading, writing and traversal

    Download zip
    Author
    Version
    0.2.0
    License
    Apache-2.0
    Repository
    Last updated
    9 hours ago
    Downloads
    7

    No dependencies

    #moonrockz/bpmn

    Portable BPMN document values, a lossless namespace-aware XML CST, source maps, writing, structural validation, explicit reference resolution and containment walking. The module imports only MoonBit core. It reads decoded strings without filesystem, network, clock or environment access.

    #Reading stages

    read(source, source_id?, limits?) scans XML, constructs the owned CST, resolves namespace scopes and lowers supported BPMN values. An XML error prevents typed lowering. XML recovery keeps malformed regions and resumes at tag boundaries. tree.complete describes the XML stage; typed lowering can still report an unsupported BPMN element/field or exhaust the diagnostic budget.

    The XML stage supports XML 1.0 names, namespaces, quoted attributes, comments, processing instructions, CDATA, mixed text, the five predefined entities and numeric character references. Its rules follow XML 1.0, fifth edition and Namespaces in XML 1.0, third edition. Namespace names compare as literal strings. Declarations apply to the whole start tag, and a default namespace applies to elements. Ordinary unprefixed attributes have an empty namespace. Duplicate expanded attribute names fail. The reserved xml binding is present without a declaration.

    ///|
    test "inspect XML namespaces and mixed content without a renderer" {
      let source = "<r xmlns='urn:r' xmlns:p='urn:p' p:a='&#x1F600;'>left<![CDATA[<raw>&]]><p:c/>right</r>"
      let result = @bpmn.read(source)
      assert_eq(result.tree.text(), source)
      assert_true(result.tree.complete)
      let root = result.tree.nodes[1]
      assert_eq(root.name.unwrap().namespace_uri, "urn:r")
      assert_eq(root.attributes[2].value, "šŸ˜€")
      assert_eq(root.children.map(i => result.tree.nodes[i].kind).iter().to_array(), [Text, CData, Element, Text])
      // This XML vocabulary has no typed BPMN projection yet.
      assert_eq(result.document, None)
    }

    The CST has flat, immutable nodes and lexical tokens. Node zero is the document; child and parent indexes refer to that CST. Element nodes expose raw and expanded names, ordered attributes, local namespace declarations, child indexes and source spans. Text/CDATA values are decoded and normalized; processing-instruction values contain data after the target. Each token retains its original text and half-open UTF-16 span. Tokens partition the source. Use tree.text() to reproduce the original spelling, including invalid XML.

    Literal CRLF and CR become LF in decoded values. Literal attribute whitespace becomes spaces; referenced whitespace retains its referenced character. CDATA and processing instructions do not expand references. Outside the root, only literal XML whitespace is allowed; references to whitespace are errors. Malformed comments, forbidden characters, invalid scalars and undeclared entities give findings. DTD, entity and other markup declarations are prohibited, with no expansion or resource resolution. Neither schema locations nor namespace URIs cause I/O.

    Input is already decoded. The optional XML declaration must name version 1.0; accepted encoding labels are case-insensitive UTF-8 and US-ASCII. An ASCII declaration fails if the input has non-ASCII characters. File decoding belongs to a host adapter. An initial Unicode BOM is retained in source reproduction.

    #Source locations

    Offsets and columns count UTF-16 code units; lines and columns start at one. CRLF is one line break. source_map.position(offset) and location(span) reject out-of-range offsets. Diagnostics have a stable code, severity, message and optional span/location. A supplied source ID is data, not a path to open.

    ///|
    test "a diagnostic after an emoji uses source coordinates" {
      let result = @bpmn.read("<r>\r\nšŸ˜€<p:x/></r>", source_id="memory:example")
      let location = result.diagnostics[0].location.unwrap()
      assert_eq(location.source_id, Some("memory:example"))
      assert_eq(location.start.line, 2)
      assert_eq(location.start.column, 4)
      assert_eq(result.document, None)
    }

    #Processing limits

    All Limits::new fields are inclusive and must be positive.

    FieldDefaultWhat it bounds
    source_units16,777,216Decoded source in UTF-16 units
    output_units16,777,216Complete generated XML in UTF-16 units
    nodes1,000,000Document, element/content nodes, attributes and namespace declarations
    depth4,096Element depth, including empty elements
    token_units1,048,576One lexical token or complete attribute/text value
    diagnostics256Findings shared by XML reading and typed lowering

    A limit finding prevents a successful typed document. The diagnostic that exceeds the finding budget replaces its last slot with xml/diagnostic-limit. Reading stops at a parser limit. The remaining raw source is retained as one error preservation token, exempt from token size; it is not decoded or expanded. Oversized source is rejected before constructing a source map or node arena. Its finding identifies offset zero and the source ID. Invalid limits produce one configuration finding without an invented source location, even when the configured diagnostic limit is zero. Source reproduction remains available.

    ///|
    test "limit exhaustion preserves the complete source" {
      let source = "<r><s/></r>"
      let result = @bpmn.read(source, limits=@bpmn.Limits::new(depth=1))
      assert_eq(result.tree.text(), source)
      assert_eq(result.document, None)
      assert_eq(result.diagnostics[0].code, "xml/depth-limit")
    }

    #XML diagnostic inventory

    All codes below have error severity. BPMN lowering codes are separate.

    CodeMeaning
    xml/invalid-limitsAt least one configured bound is not positive
    xml/source-limitSource exceeds its UTF-16 bound
    xml/node-limitNode/attribute records exceed their bound
    xml/depth-limitElement depth exceeds its bound
    xml/token-limitA lexical token or attribute/text value is too large
    xml/diagnostic-limitThe next finding exceeds the shared budget
    xml/invalid-characterA literal character is forbidden in XML 1.0
    xml/invalid-nameAn element/attribute name is not a qualified XML name
    xml/invalid-tagAttribute quoting, spacing or tag punctuation is malformed
    xml/unclosed-tagAn open element remains at end of input
    xml/mismatched-tagA closing tag does not match the current open element
    xml/duplicate-attributeAttribute expanded names or namespace declarations repeat
    xml/undeclared-prefixA qualified element/attribute uses an unbound prefix
    xml/invalid-namespaceA reserved binding or prefix undeclaration is invalid
    xml/character-referenceA reference is malformed, undeclared or not an XML scalar
    xml/outside-rootNon-whitespace text or CDATA occurs outside the document element
    xml/root-requiredThe source does not contain exactly one document element
    xml/invalid-commentA comment contains -- or ends with -
    xml/unclosed-commentA comment has no closing delimiter
    xml/unclosed-cdataA CDATA section has no closing delimiter
    xml/invalid-piA processing instruction has an invalid or reserved target
    xml/unclosed-piA processing instruction has no closing delimiter
    xml/invalid-declarationThe declaration has invalid position, version or pseudo-attributes
    xml/encodingThe declared encoding is unsupported or conflicts with the decoded input
    xml/prohibited-declarationDTD/entity/other markup declarations are prohibited
    xml/cdata-close]]> occurs in ordinary character data

    ///|
    test "the documented inventory agrees with the exported codes" {
      assert_eq(@bpmn.xml_diagnostic_codes.iter().to_array(), [
        "xml/invalid-limits", "xml/source-limit", "xml/node-limit", "xml/depth-limit",
        "xml/token-limit", "xml/diagnostic-limit", "xml/invalid-character",
        "xml/invalid-name", "xml/invalid-tag", "xml/unclosed-tag", "xml/mismatched-tag",
        "xml/duplicate-attribute", "xml/undeclared-prefix", "xml/invalid-namespace",
        "xml/character-reference", "xml/outside-root", "xml/root-required",
        "xml/invalid-comment", "xml/unclosed-comment", "xml/unclosed-cdata",
        "xml/invalid-pi", "xml/unclosed-pi", "xml/invalid-declaration", "xml/encoding",
        "xml/prohibited-declaration", "xml/cdata-close",
      ])
    }

    #Typed BPMN values and writing

    The five frozen BPMN 2.0.2 schemas drive the standard Kind alternatives, TypeId, type derivation, substitution groups, fields, occurrence bounds, choices and named enumeration types. schema_types, schema_elements, schema_fields and schema_groups expose this read-only inventory. Run mise run bpmn-schema:generate to regenerate it. validate:bpmn-schema checks input digests and byte-identical regeneration, including the declaration coverage manifest under tests/corpus/bpmn-2.0.2/coverage.json.

    Element holds a standard kind, schema type identity, typed Scalar attributes, optional scalar text, and ordered Content. Content distinguishes text, elements, comments and inert processing instructions. Constructors copy input collections into read-only arrays. Updating an element returns a new value. Parsed elements retain their effective namespace context in a shared immutable core map, so content updates keep inherited QName bindings and prefix shadowing without copying every ancestor binding into every descendant. Document holds its root plus ordered prolog and epilog comments/instructions. Outside-root whitespace is source trivia and is omitted from document values.

    Definitions, Import, BaseElement, RootElement and Documentation give typed foundation construction or inspection. Abstract base/root views require a concrete element whose schema type derives from that base. Process and collaboration wrappers cover activities, subprocesses, calls, loop and multi-instance values, events/definitions, gateways, flows, pools/participants, lanes, data, artifacts, resources and shared definitions. The generated typed_model_types and typed_model_fields inventories let qualification check every selected schema type and inherited field. Choreography, conversation, BPMNDI/DI/DC and preserved vendor XML are also qualified. Every complex type in the five frozen schemas has a typed view, including the anonymous DI extension container. Unknown standard elements or unknown types give findings and remain available as preserved XML inside the document. Foreign namespace content does not require a vendor plugin. Structure validation, reference-resource resolution and full traversal follow in later groups. Reading or writing does not validate all BPMN constraints.

    ///|
    test "construct immutable foundations without inserting defaults" {
      let documentation = @bpmn.Documentation::new([Text("Review & approve")])
      let process = @bpmn.Element::new(Process, attributes=[("id", "P")], children=[documentation.element])
      let definitions = @bpmn.Definitions::new("urn:example", children=[process])
      let document = definitions.document()
      assert_eq(definitions.roots()[0].base().id(), Present("P"))
      assert_eq(process.boolean("isExecutable"), Absent)
      assert_eq(documentation.text_format(), Absent)
      let compact = @bpmn.write(document)
      let pretty = @bpmn.write(document, format=Pretty)
      assert_false(compact.contains("textFormat"))
      assert_eq(@bpmn.read(compact).document, Some(document))
      assert_eq(@bpmn.read(pretty).document, Some(document))
    }

    Field[T] distinguishes Absent, Present(value) and InvalidValue(scalar). Absent schema defaults stay absent. Booleans, identifiers, URIs, exact integers, exact numeric tokens, references and generated enumeration alternatives have separate Scalar cases. ExactNumber retains the DI token without passing through a host float. Decimal fractions and exponent tokens therefore keep all digits. XML Schema double also admits INF, -INF and NaN; is_finite() distinguishes them. ExactInteger has no host integer-size limit; fields declared as XML Schema int enforce its signed 32-bit range. String whitespace is retained; token, URI, numeric and reference types apply their schema whitespace policy. Invalid scalar spellings remain inspectable in a typed document with findings, and cannot be written as valid values.

    References retain original spelling plus expanded namespace identity. ReferenceKind::Id uses a local NCName; QName resolves prefixes against explicit bindings. No external document is opened. Construct references from an ExpandedName to avoid inventing a source prefix. Element::new accepts string attributes with explicit local bindings; Element::from_values accepts typed attributes, optional typed scalar text and ordered content. A local child name whose schema type depends on its parent needs an explicit value_type when constructed outside that context. The writer rejects a missing or conflicting type identity instead of producing a document that reads back differently. An explicit type override adds the corresponding xsi:type reference so it survives serialization. No IDs or DI are generated.

    ///|
    test "constructed references carry expanded identity" {
      let source = @bpmn.Reference::new(@bpmn.ExpandedName::new("urn:other", "Task"))
      let flow = @bpmn.Element::from_values(MessageFlow, values=[
        @bpmn.Attribute::new(@bpmn.ExpandedName::new("", "sourceRef"), Reference(source)),
      ])
      let document = @bpmn.Definitions::new("urn:example", children=[flow]).document()
      let xml = @bpmn.write(document)
      assert_true(xml.contains("xmlns:ns1=\"urn:other\""))
      assert_true(xml.contains("sourceRef=\"ns1:Task\""))
      assert_eq(@bpmn.read(xml).document, Some(document))
    }

    #Equality, source reproduction and canonical output

    Document equality compares standard kind/type, expanded attribute names, typed scalar values and ordered semantic content. It ignores source spans, raw prefix aliases, attribute ordering and element-only formatting whitespace. Adjacent text/CDATA normalize to text values. Mixed content, comments, processing instructions and inherited xml:space are retained. Exact number tokens compare exactly. Namespace aliases on known QName values compare by expanded identity.

    tree.text() reproduces the source bytes represented by the decoded string, including quote style, CDATA, declarations and invalid regions. write produces this library's deterministic XML format, not XML C14N. The default is compact; format=Pretty uses two spaces for element-only content. Both keep mixed text and containment order. Pretty output adds no whitespace inside mixed content, scalar elements or an inherited xml:space='preserve' scope.

    Canonical namespaces use bpmn, bpmndi, dc, di, xml and xsi for known URIs, and ns1, ns2, ... for other used QName identities in sorted lexical URI order. Known bindings are declared at the root. Unused aliases on ordinary known values disappear. Attributes sort by namespace URI, then local name. Namespace names are literal strings; they do not trigger I/O. Known QName tokens are rewritten with matching bindings. Preserved XML and opaque attributes retain their effective bindings in local scopes. Their source prefixes are retained when valid, and canonical parent prefixes cannot rebind opaque values.

    ///|
    test "source reproduction and canonical writing serve different purposes" {
      let source = "<d:definitions xmlns:d='http://www.omg.org/spec/BPMN/20100524/MODEL' targetNamespace='urn:example'><d:process id='P'/></d:definitions>"
      let result = @bpmn.read(source)
      assert_eq(result.tree.text(), source)
      let document = result.document.unwrap()
      let canonical = @bpmn.write(document)
      assert_false(canonical == source)
      assert_eq(@bpmn.read(canonical).document, Some(document))
      assert_eq(@bpmn.write(@bpmn.read(canonical).document.unwrap()), canonical)
    }

    #Writer failures and limits

    try_write(document, format?, limits?) returns WriteResult with either complete output or diagnostics. It never exposes a partial buffer. write is a convenience API that returns the string or raises WriteError::Failed(diagnostics). This adds a checked error to the earlier provisional convenience API.

    The writer checks XML names/characters, namespace bindings, duplicate expanded attributes, typed scalar consistency, comments and processing instructions. It rejects unbound QName references, invalid scalars and incompatible xsi:type values. Namespace bindings must obey XML reserved-prefix rules. Comments cannot contain -- or end with -. Comment/PI CR and leading PI data whitespace are rejected because XML normalization would change their value. Construct text CR is preserved through a character reference instead.

    ///|
    test "invalid QName binding returns an explicit failure" {
      let flow = @bpmn.Element::new(MessageFlow, attributes=[("sourceRef", "missing:T")])
      let document = @bpmn.Definitions::new("urn:example", children=[flow]).document()
      let result = @bpmn.try_write(document)
      assert_eq(result.output, None)
      assert_eq(result.diagnostics[0].code, "bpmn/unbound-qname")
      let reserved = @bpmn.Element::new(Definitions, bindings=[("xml", "urn:wrong")])
      assert_eq(@bpmn.try_write(@bpmn.Document::new(reserved)).diagnostics[0].code, "bpmn/namespace-conflict")
    }

    The writer uses explicit stacks for preflight and emission, including very deep constructed documents. It checks depth and node/attribute/binding counts before descending. It bounds complete output and individual escaped tokens before appending. Canonical namespace declarations count toward output records. Input and output record counts each obey nodes; neither is the sum of both passes. Pretty indentation also obeys the token/output bounds. Limits must be positive; source_units applies to reading, while output_units applies to writing. Writer failure produces one error with an optional original span. Constructed values have no invented source location.

    Writer codes are bpmn/output-limit, bpmn/write-node-limit, bpmn/write-depth-limit, bpmn/write-token-limit, bpmn/write-invalid-limits, bpmn/forbidden-text, bpmn/invalid-name, bpmn/namespace-conflict, bpmn/invalid-scalar, bpmn/scalar-type-mismatch, bpmn/unbound-qname, bpmn/type-conflict, bpmn/duplicate-attribute, bpmn/invalid-content, bpmn/invalid-comment, bpmn/invalid-pi, bpmn/outside-root, bpmn/definitions-required and bpmn/unsupported-type. Lowering uses bpmn/unsupported-element, bpmn/unsupported-type, bpmn/unsupported-attribute, bpmn/invalid-scalar, bpmn/unbound-qname and bpmn/definitions-required. These findings do not change the XML CST's completeness. A simple walk visits containment in preorder and never follows reference attributes.

    #Typed process and collaboration APIs

    Named wrappers expose their immutable element and schema-typed accessors. UserTask::from_element, for example, checks type derivation before returning a view. FlowElement, Activity, CatchEvent and other abstract wrappers can inspect their concrete subtypes. new constructors exist for concrete global elements. Constructor arguments include inherited attributes with their scalar, reference or named enum type. Child order is explicit in contents.

    Single child accessors return Field[T]. Repeated children return Field[ReadOnlyArray[T]]; no children gives Absent. A mismatched scalar or child type gives InvalidValue, and a duplicate singleton child is invalid. The original ordered elements remain available on element.children. Names use snake case; reserved words gain _, as in default_ and method_. The BPMN Error wrapper is BpmnError because Error is reserved by MoonBit.

    ///|
    test "construct and inspect a typed process" {
      let task = @bpmn.UserTask::new(id="Review", name="Review request", implementation=Unspecified)
      let process = @bpmn.Process::new(id="P", is_executable=false, contents=[Element(task.element)])
      let document = @bpmn.Definitions::new("urn:example", children=[process.element]).document()
      assert_eq(task.is_for_compensation(), Absent)
      assert_eq(process.flow_element().value().unwrap()[0].element.kind, UserTask)
      let reread = @bpmn.read(@bpmn.write(document)).document.unwrap()
      let view = @bpmn.Process::from_element(reread.root.children[0]).unwrap()
      assert_eq(view.is_executable(), Present(false))
      assert_eq(@bpmn.UserTask::from_element(view.flow_element().value().unwrap()[0].element).unwrap().name(), Present("Review request"))
    }

    References keep their schema distinction. A sequence-flow endpoint is an ID reference; message-flow endpoints and participant process references are QNames. Use kind=Id when constructing an ID reference. The writer reports a mismatch rather than changing one alternative into another. Formal expressions remain inert text. To put one under a property name such as conditionExpression, use with_kind; its explicit type identity is retained through xsi:type.

    ///|
    test "construct descriptive conditions and ID references" {
      let condition = @bpmn.FormalExpression::new(language="urn:description", contents=[Text("approved == true")]).element.with_kind(ConditionExpression)
      let flow = @bpmn.SequenceFlow::new(id="F", source_ref=@bpmn.Reference::new(@bpmn.ExpandedName::new("", "A"), kind=Id), target_ref=@bpmn.Reference::new(@bpmn.ExpandedName::new("", "B"), kind=Id), contents=[Element(condition)])
      let process = @bpmn.Process::new(id="P", contents=[Element(@bpmn.Task::new(id="A").element), Element(@bpmn.Task::new(id="B").element), Element(flow.element)])
      let document = @bpmn.Definitions::new("urn:example", children=[process.element]).document()
      assert_eq(flow.condition_expression().value().unwrap().element.content, "approved == true")
      assert_eq(@bpmn.read(@bpmn.write(document)).document, Some(document))
    }

    ///|
    test "construct a collaboration independently of rendering" {
      let buyer = @bpmn.Process::new(id="Buyer", contents=[Element(@bpmn.SendTask::new(id="Send").element)])
      let seller = @bpmn.Process::new(id="Seller", contents=[Element(@bpmn.ReceiveTask::new(id="Receive").element)])
      let buyer_pool = @bpmn.Participant::new(id="BuyerPool", process_ref=@bpmn.Reference::new(@bpmn.ExpandedName::new("", "Buyer")))
      let seller_pool = @bpmn.Participant::new(id="SellerPool", process_ref=@bpmn.Reference::new(@bpmn.ExpandedName::new("", "Seller")))
      let message = @bpmn.MessageFlow::new(id="Request", source_ref=@bpmn.Reference::new(@bpmn.ExpandedName::new("", "Send")), target_ref=@bpmn.Reference::new(@bpmn.ExpandedName::new("", "Receive")))
      let collaboration = @bpmn.Collaboration::new(id="Exchange", contents=[Element(buyer_pool.element), Element(seller_pool.element), Element(message.element)])
      let document = @bpmn.Definitions::new("urn:example", children=[buyer.element, seller.element, collaboration.element]).document()
      assert_eq(collaboration.participant().value().unwrap().length(), 2)
      assert_eq(@bpmn.read(@bpmn.write(document, format=Pretty)).document, Some(document))
    }

    Construction can represent an incomplete intermediate value. The writer checks XML/scalar representability and type identity; required-field and structural validation are completed in group 6. These document APIs do not expand the current renderer's coverage or execute conditions, events, loops or scripts.

    The unpublished corpus compares core identities, containment, references and minimal DI with bpmn-moddle@10.3.1. mise run bpmn-corpus:reference refreshes those frozen JSON fixtures using its private lockfile. Ordinary module tests use the committed data, without JavaScript dependencies or resource access. See tests/corpus/bpmn-model/README.md for normalization rules and the explicit GlobalScriptTask schema/reference difference. Exact numeric preservation and source order have separate four-target laws, beyond the reference's numeric and property-order conventions.

    #Choreography, conversation and DI values

    Choreography, GlobalChoreographyTask, ChoreographyTask, SubChoreography and CallChoreography retain participant/message references, nested flow content, associations and loop descriptions. Conversation, SubConversation, CallConversation, GlobalConversation, links and associations have their own typed views. These are document values. Choreography/conversation rendering is explicitly deferred, and the adapter returns bpmn/unsupported-view for those views. They are not converted into generic tasks.

    ///|
    test "construct a choreography document without rendering it" {
      let task = @bpmn.ChoreographyTask::new(id="Exchange", initiating_participant_ref=@bpmn.Reference::new(@bpmn.ExpandedName::new("", "A")), contents=[
        Element(@bpmn.Element::new(ParticipantRef, content="A")),
        Element(@bpmn.Element::new(ParticipantRef, content="B")),
        Element(@bpmn.Element::new(MessageFlowRef, content="M")),
      ])
      let flow = @bpmn.MessageFlow::new(id="M", source_ref=@bpmn.Reference::new(@bpmn.ExpandedName::new("", "A")), target_ref=@bpmn.Reference::new(@bpmn.ExpandedName::new("", "B")))
      let choreography = @bpmn.Choreography::new(id="C", contents=[Element(@bpmn.Participant::new(id="A").element), Element(@bpmn.Participant::new(id="B").element), Element(flow.element), Element(task.element)])
      let document = @bpmn.Definitions::new("urn:example", children=[choreography.element]).document()
      assert_eq(task.loop_type(), Absent)
      assert_eq(@bpmn.read(@bpmn.write(document)).document, Some(document))
    }

    ///|
    test "construct a conversation and its participant links" {
      let conversation = @bpmn.Conversation::new(id="Order", name="Order details", contents=[Element(@bpmn.Element::new(ParticipantRef, content="Buyer")), Element(@bpmn.Element::new(ParticipantRef, content="Seller"))])
      let link = @bpmn.ConversationLink::new(id="BuyerLink", source_ref=@bpmn.Reference::new(@bpmn.ExpandedName::new("", "Buyer")), target_ref=@bpmn.Reference::new(@bpmn.ExpandedName::new("", "Order")))
      let collaboration = @bpmn.Collaboration::new(id="C", contents=[Element(@bpmn.Participant::new(id="Buyer").element), Element(@bpmn.Participant::new(id="Seller").element), Element(conversation.element), Element(link.element)])
      let document = @bpmn.Definitions::new("urn:example", children=[collaboration.element]).document()
      assert_eq(collaboration.conversation_node().value().unwrap().length(), 1)
      assert_eq(@bpmn.read(@bpmn.write(document)).document, Some(document))
    }

    BpmnDiagram, BpmnPlane, BpmnShape, BpmnEdge, BpmnLabel and BpmnLabelStyle expose the BPMNDI fields. Di* views expose their DI bases; DcBounds, DcPoint and DcFont retain exact numeric tokens and display flags. A document can have multiple diagrams/planes or no DI. Diagram-element IDs, label styles, waypoints and participant-band references remain distinct fields.

    ///|
    test "construct exact DI bounds and a plane" {
      let bounds = @bpmn.DcBounds::new(x=@bpmn.ExactNumber::parse("123.456789012345678901").unwrap(), y=@bpmn.ExactNumber::parse("0").unwrap(), width=@bpmn.ExactNumber::parse("100").unwrap(), height=@bpmn.ExactNumber::parse("80").unwrap())
      let shape = @bpmn.BpmnShape::new(id="Shape", bpmn_element=@bpmn.Reference::new(@bpmn.ExpandedName::new("", "T")), is_expanded=false, contents=[Element(bounds.element)])
      let plane = @bpmn.BpmnPlane::new(id="Plane", bpmn_element=@bpmn.Reference::new(@bpmn.ExpandedName::new("", "P")), contents=[Element(shape.element)])
      let diagram = @bpmn.BpmnDiagram::new(id="Diagram", contents=[Element(plane.element)])
      let process = @bpmn.Process::new(id="P", contents=[Element(@bpmn.Task::new(id="T").element)])
      let document = @bpmn.Definitions::new("urn:example", children=[process.element, diagram.element]).document()
      assert_eq(shape.bounds().value().unwrap().x().value().unwrap().token, "123.456789012345678901")
      assert_eq(@bpmn.read(@bpmn.write(document, format=Pretty)).document, Some(document))
    }

    #Preserved XML and opaque namespace scopes

    XmlElement and XmlContent construct preserved XML from expanded names, string-valued attributes, ordered text/elements/comments/instructions and explicit namespace bindings. Insert its element under an extension container. element.xml() inspects foreign or unsupported standard XML. A known BPMN name inside an opaque payload stays XML payload data, with no inferred BPMN meaning. opaque_attributes() exposes uninterpreted fields on an otherwise typed node.

    Parsed payloads keep their complete effective namespace context in shared immutable maps, including inherited and unused bindings. namespace_binding on either Element or XmlElement queries this captured scope. Constructed standalone values expose their explicit bindings; a constructed tree inherits bindings from its containing values. Copying a parsed payload keeps its captured context. Prefix shadowing is kept locally, including when a vendor uses bpmn for another URI. Names use source prefixes inside preserved scopes and fresh aliases when required. No existing binding is silently reassigned to change an opaque value.

    ///|
    test "construct a mixed vendor extension with a QName-sensitive value" {
      let payload = @bpmn.XmlElement::new(@bpmn.ExpandedName::new("urn:vendor", "payload"), attributes=[(@bpmn.ExpandedName::new("", "ref"), "q:Target")], contents=[Text("before "), Comment("inert"), Text(" after")], bindings=[("q", "urn:target"), ("unused", "urn:retained")])
      let extensions = @bpmn.ExtensionElements::new(contents=[Element(payload.element)])
      let process = @bpmn.Process::new(id="P", contents=[Element(extensions.element)])
      let document = @bpmn.Definitions::new("urn:example", children=[process.element]).document()
      let copy = @bpmn.read(@bpmn.write(document)).document.unwrap()
      let retained = copy.root.children[0].children[0].children[0].xml().unwrap()
      assert_eq(retained.namespace_binding("q"), Some("urn:target"))
      assert_eq(retained.namespace_binding("unused"), Some("urn:retained"))
      assert_eq(copy, document)
    }

    Unknown standard elements give bpmn/unsupported-element. Unknown xsi:type values give bpmn/unsupported-type; the affected subtree remains opaque XML. Unknown standard attributes give bpmn/unsupported-attribute and retain their value. These findings can coexist with an inspectable, writable document. Its CST still reproduces the original text. A root with an unknown type can have no Definitions view, while its preserved root remains inspectable. A syntax error or processing-limit failure still prevents a successful complete document.

    Opaque equality compares expanded names, raw values, ordered content, the default namespace and bindings used by QName-looking tokens. It does not claim to understand vendor semantics. The writer separately retains every original binding, including bindings whose use is unknown. Prefixes that were unbound in opaque tokens are kept unbound; canonical prefix allocation avoids those names. If a copied closed scope would require undeclaring an inherited nonempty prefix, XML Namespaces 1.0 cannot represent it, so writing returns bpmn/namespace-conflict. An empty-namespace identity conflicting with a preserved default namespace also returns that error. No partial XML is exposed.

    Namespace output uses only changed declarations. Source contexts and changes share immutable data across siblings; the acceptance suite exercises wide scopes with 1,000 bindings and 2,000 shadowing children. Preserved declarations, names and escaped values obey the same node, token and output limits as known BPMN data. No vendor text, URI or expression triggers I/O or execution.

    The provisional group-4 API returned raw Element values from collaboration conversation-node, conversation-link and conversation-association accessors. These accessors now return their respective typed views. Use .element when an existing caller needs the underlying element.

    #Structural validation and explicit reference resources

    validate_structure(document, resource_id?, limits?) returns an immutable source-order DocumentIndex and structural findings. It checks required fields, occurrences, sequence order, schema choices, abstract declarations, scalar alternatives and containment types across every generated schema family. IDs come from declared ID fields. IDs inside opaque XML do not become BPMN targets. index.lookup(id) returns Found, Ambiguous, Missing or Incomplete. Duplicate occurrences retain their source order.

    resolve_references(index, resources?, resource_id?, limits?) checks all 114 declared QName/IDREF fields against reference_rules. The semantic target table supplements XSD primitive types with the BPMN 2.0.2 metamodel, including its normative CMOF. Checks include target kinds, boundary attachments, sequence-flow scope, default/incoming/outgoing endpoints and lane membership. DI plane references must name one of the allowed process, collaboration or choreography containers. This does not validate execution, expressions, vendor semantics or every BPMN modeling constraint. It never simulates tokens or evaluates conditions.

    validate(document, ...) combines both stages. validate_read(read_result, ...) also retains earlier findings with explicit Syntax, Structure or References stages. complete means processing finished within bounds. A complete result can have error findings and still retain the original inspectable document.

    ///|
    test "validate a valid process and inspect incomplete authored fields" {
      let task=@bpmn.Task::new(id="T")
      let process=@bpmn.Process::new(id="P",contents=[Element(task.element)])
      let document=@bpmn.Definitions::new("urn:example",children=[process.element]).document()
      let valid=@bpmn.validate(document)
      assert_true(valid.complete)
      assert_eq(valid.findings,[])
      assert_true(valid.index.unwrap().lookup("T") is Found(_))
      let bad=@bpmn.SequenceFlow::new(id="MissingEndpoints")
      let document=@bpmn.Definitions::new("urn:example",children=[@bpmn.Process::new(contents=[Element(bad.element)]).element]).document()
      let invalid=@bpmn.validate(document)
      assert_true(invalid.complete)
      assert_eq(invalid.document,Some(document))
      assert_true(invalid.findings.iter().any(f => f.diagnostic.code == "bpmn/required-field" && f.element_id == Some("MissingEndpoints")))
      assert_true(invalid.findings.iter().all(f => f.diagnostic.location == None))
    }

    ResourceSet::new(documents?, external?) copies caller arrays. A DocumentResource has a literal location key and a typed document. Import lookup uses exactly that key, declared namespace and import type. The caller handles relative paths or URLs before supplying the set. A supplied resource becomes visible only through the root's direct or transitive imports. Cycles stop at already visited resources. Two keys can supply documents with the same target namespace; duplicate target IDs then produce ambiguity. Duplicate location keys produce an ambiguous-import finding. No candidate wins by array order.

    An ExternalResource supplies a location, namespace, import type and explicit NCName symbol identities for another language. This is a symbol table supplied by the caller, not a parser or validator for XML Schema, WSDL or vendor content. External symbols can satisfy generic language references, and cannot satisfy a reference that requires a BPMN process, task or other specific BPMN type.

    ///|
    test "resolve an imported process using only explicit resources" {
      let model="http://www.omg.org/spec/BPMN/20100524/MODEL"
      let imported=@bpmn.Definitions::new("urn:imported",children=[@bpmn.Process::new(id="Reusable").element]).document()
      let reference=@bpmn.Reference::new(@bpmn.ExpandedName::new("urn:imported","Reusable"))
      let participant=@bpmn.Participant::new(id="Pool",process_ref=reference)
      let document=@bpmn.Definitions::new("urn:main",children=[@bpmn.Import::new("urn:imported","reusable.bpmn",model).element,@bpmn.Collaboration::new(contents=[Element(participant.element)]).element]).document()
      let resources=@bpmn.ResourceSet::new(documents=[@bpmn.DocumentResource::new("reusable.bpmn",imported)])
      let index=@bpmn.validate_structure(document).index
      let result=@bpmn.resolve_references(index,resources~)
      assert_eq(result.findings,[])
      assert_true(result.resolve(reference) is Found(found) && found.resource_id == Some("reusable.bpmn"))
      let missing=@bpmn.resolve_references(index)
      assert_true(missing.complete)
      assert_true(missing.findings.iter().any(f => f.diagnostic.code == "bpmn/unresolved-import"))
    }

    IDREF and empty-namespace QName values are document-local. Every nonempty QName namespace matches a definitions target namespace literally. XML default namespaces apply to QName values too. A model-vocabulary namespace is not an alias for the current target namespace. Bind a prefix to the intended target namespace when needed. This policy preserves expanded identity through writing and prevents a qualified reference from falling back to a same-named local ID. Missing unrelated imports remain findings while local queries still work. resolve returns Found, External, Ambiguous, Unresolved, Invalid or Limit; the original reference value always remains available.

    Source-backed elements and attributes retain their own immutable source origin. location() stays correct when they are copied between documents. New or edited element values have no element span. Unchanged copied attributes can still have their original locations. Findings identify the owner ID and field without inventing locations for constructed values. Source provenance is excluded from document semantic equality.

    Validation uses Limits. Structure counts document, element, content, attribute and namespace records; depth and token bounds are inclusive. An index built after limit exhaustion cannot answer a lookup as missing. Reference resources share the node budget across imported documents and external symbols. Candidate visits and matched target occurrences consume a separate query-work budget of limits.nodes across field resolution, and each explicit resolve call gets that budget independently. Namespace and ID indexes avoid scanning unrelated resources. Diagnostic overflow replaces the final slot with the limit finding.

    The exported diagnostic inventory below is checked by this runnable example. All listed codes have error severity.

    ///|
    test "document the complete structural and reference diagnostic inventory" {
      let codes : ReadOnlyArray[String] = [
        "bpmn/validation-invalid-limits", // A bound is not positive.
        "bpmn/validation-node-limit", // Structure record budget exhausted.
        "bpmn/validation-depth-limit", // Containment depth exhausted.
        "bpmn/validation-token-limit", // One value exceeds its token bound.
        "bpmn/validation-diagnostic-limit", // Finding budget exhausted.
        "bpmn/duplicate-id", // Multiple declared IDs have the same value.
        "bpmn/required-field", // Required field or selected branch is absent.
        "bpmn/field-cardinality", // Too many occurrences of one field.
        "bpmn/invalid-containment", // Wrong root, child or text containment.
        "bpmn/child-order", // Child is outside schema sequence order.
        "bpmn/choice-conflict", // Multiple choice branches are present.
        "bpmn/abstract-element", // Abstract declaration was instantiated.
        "bpmn/invalid-field", // Undeclared field or invalid scalar alternative.
        "bpmn/invalid-type", // Incompatible actual or containment type.
        "bpmn/unresolved-reference", // No identity in the explicit import closure.
        "bpmn/ambiguous-reference", // Several identities match.
        "bpmn/invalid-reference", // Invalid/unbound QName, IDREF or external symbol.
        "bpmn/wrong-reference-kind", // Identity exists with an incorrect type.
        "bpmn/sequence-flow-scope", // Flow endpoint crosses its flow scope.
        "bpmn/boundary-attachment", // Attachment is outside the owning flow scope.
        "bpmn/reference-endpoint", // Default, lane, incoming/outgoing inconsistency.
        "bpmn/unresolved-import", // Location key was not supplied.
        "bpmn/ambiguous-import", // Several resources have the same location key.
        "bpmn/import-namespace", // Import and supplied namespace differ.
        "bpmn/import-type", // Import and supplied resource type differ.
        "bpmn/resource-limit", // Resource or lookup-work budget exhausted.
      ]
      assert_eq(@bpmn.validation_diagnostic_codes,codes)
    }

    #Read-only traversal

    DocumentTree::new(document, resource_id?, limits?) builds an immutable index over the existing document values. It does not require semantic validity and does not resolve references. Its document root contains prolog content, the definitions element and epilog content. Element children include retained text, comments and processing instructions, with vendor XML in original model order. XML formatting trivia omitted during typed lowering stays in the lossless CST.

    NodeRef exposes value, category, XML kind, declared id, attributes, scalar, fields, children, parent, step, depth, span, location, resource_id, path and handle. A NodeField groups present attributes and children without adding defaults. Known containment uses schema field names, including substitution heads such as flowElement; opaque children use their expanded XML names. PathField distinguishes named fields, text, comments, PI, root, prolog and epilog. PathStep records the index within that field and the absolute ordered-content index. Unbound attribute names remain inspectable via attributes, without an invented expanded identity.

    A NodePath is a constant-size view; steps() allocates the requested path. Depth and paths are relative to the document root, including when a traversal starts at a subtree. Source-backed content has optional source locations. Constructed or replaced content has no invented span. Copied elements keep their own origins. Replacing contents preserves child-element origins, and clears source spans for newly supplied text/comment/PI values.

    tree.lookup(handle) and path.resolve(tree) return Found, DocumentMismatch or InvalidHandle. Revision checks compare resource identity, complete source identity and constructed values, including unused bindings and lexical metadata. Semantic document equality alone is insufficient. Two trees built from the same immutable revision can exchange handles. Canonical writing and reading creates a new source revision. There is no global allocation counter or hash-only ownership test.

    ///|
    test "locate a nested task and reject a handle from another revision" {
      let task=@bpmn.Task::new(id="T")
      let sub=@bpmn.SubProcess::new(id="Sub",contents=[Element(task.element)])
      let doc=@bpmn.Definitions::new("urn:t",children=[@bpmn.Process::new(id="P",contents=[Element(sub.element)]).element]).document()
      let tree=@bpmn.DocumentTree::new(doc).tree.unwrap()
      let tasks=[]
      @bpmn.walk(tree.root(),n => { if n.id() == Some("T") { tasks.push(n) }; Continue })
      let node=tasks[0]
      assert_eq(node.parent().unwrap().id(),Some("Sub"))
      assert_eq(node.path().steps().last().unwrap().field,Named(@bpmn.Kind::FlowElement.name()))
      assert_eq(node.location(),None)
      assert_true(node.path().resolve(tree) is Found(found) && found == node)
      let changed=@bpmn.Definitions::new("urn:changed").document()
      assert_true(@bpmn.DocumentTree::new(changed).tree.unwrap().lookup(node.handle()) is DocumentMismatch)
    }

    walk takes an enter callback and an optional leave callback. Enter returns Continue, SkipChildren or Stop. A skipped node still receives leave; stop emits no later enter or leave callbacks. fold threads an accumulator through the same order. reduce combines child results bottom up; reduce_pruned also takes enter control, supplies an empty child-result view for skipped children, and returns None after stop.

    EventReader::new(root) exposes the same order as pull TraversalEvent::Enter and Leave values. Each event contains its NodeRef, including path and source identity. skip_children() acts immediately after enter; elsewhere it does nothing. stop() makes subsequent reads return None. EventSource permits other event producers, and push_events drives them with the same controls.

    ///|
    test "walking folding reduction and pull events count the same nodes" {
      let doc=@bpmn.Definitions::new("urn:t",children=[@bpmn.Process::new(contents=[Element(@bpmn.Task::new(id="T").element)]).element]).document()
      let root=@bpmn.DocumentTree::new(doc).tree.unwrap().root()
      let mut entered=0
      @bpmn.walk(root,_ => { entered+=1; Continue })
      let folded=@bpmn.fold(root,0,(count,_) => (count+1,Continue))
      let reduced=@bpmn.reduce(root,(_ : @bpmn.NodeRef,children : ArrayView[Int]) => 1+children.iter().fold(init=0,(sum,n) => sum+n))
      let reader=@bpmn.EventReader::new(root)
      assert_eq(reader.iter().count(),entered*2)
      assert_eq(folded,entered); assert_eq(reduced,entered)
      let cursor=@bpmn.TreeCursor::new(root)
      assert_true(cursor.goto_first_child())
      assert_eq(cursor.node().category(),Definitions)
      assert_true(cursor.goto_parent()); assert_eq(cursor.node(),root)
    }

    Visitor has default methods, so implement only the categories you need. Its optional enter(NodeRef) runs first; if it returns Continue, a typed family method runs next. Typed methods cover definitions, processes, activities, events, gateways, sequence flows, collaborations, participants, lanes, choreography, choreography activities, conversations, links and opaque XML. visit_diagram_interchange and visit_other expose other families through their read-only node views and typed element projections. Text, comment, PI and the document have their own methods. leave runs for every completed visited node. accept(root, visitor) uses the common traversal engine.

    TreeCursor supports parent, first/last child and adjacent siblings. A failed move preserves its position. It stays within its chosen start subtree; depth is relative to that start while path remains document-relative. Each walk, reader, reduction and cursor owns its state. Nested walks are independent. Explicit heap stacks handle 10,000 nested constructed elements on all targets when the configured element-depth bound allows them. The older Document::walk(Element -> Unit) remains an element-only convenience.

    #Structural graph queries

    DocumentGraph::new(document, resources?, resource_id?, limits?, graph_limits?) indexes the explicit document/import closure. It retains validation findings, and checks each imported document against that document's own import visibility. GraphNode::Document holds a revision-bound NodeRef. External holds an explicit external-language symbol and its occurrence, as a leaf. No URL or filesystem lookup occurs. An invalid reference becomes a query failure when the selected search encounters it; an unrelated disconnected component can still be queried. Processing exhaustion returns no apparently complete graph.

    GraphEdgeKind distinguishes containment, sequence flow, message flow, association, data association, conversation links and general references. General references run from the owning element to its target. A sequence-flow edge runs between its authored endpoints and retains the flow as connection. Data associations with several sources have one edge per source. Valid source-less data assignments retain their target as a general reference; no visual source is inferred. DI coordinates, labels and XML adjacency never create connections.

    GraphEndpoint selects a root-document Id, a namespace-aware Qualified identity, a revision-bound Node handle, or an explicit external Symbol. lookup returns the selected graph node or a typed failure. Root ID lookup does not select an imported element with a same-named ID.

    reachable includes the start once. route returns one shortest directed route, with authored connection order breaking ties. Both default to sequence flow in the forward direction; callers explicitly select edge kinds and Forward, Reverse or Both. A reverse route keeps each edge's authored source and target. Returned nodes and connection owners preserve source identities. These are structural routes, not execution paths or token simulations.

    ///|
    test "query a bounded structural route without executing a process" {
      let source="<b:definitions xmlns:b='http://www.omg.org/spec/BPMN/20100524/MODEL' targetNamespace='urn:t'><b:process><b:task id='A'/><b:task id='B'/><b:task id='C'/><b:sequenceFlow id='AB' sourceRef='A' targetRef='B'/><b:sequenceFlow id='BC' sourceRef='B' targetRef='C'/></b:process></b:definitions>"
      let graph=@bpmn.DocumentGraph::new(@bpmn.read(source).document.unwrap()).graph.unwrap()
      guard graph.route(Id("A"),Id("C")) is Found(route) else { fail("route missing") }
      assert_eq(route.nodes.iter().map(n => n.id()).to_array(),[Some("A"),Some("B"),Some("C")])
      assert_eq(route.edges[0].connection.unwrap().id(),Some("AB"))
      assert_true(graph.route(Id("C"),Id("A")) is Unreachable)
      assert_true(graph.route(Id("A"),Id("C"),limits=@bpmn.GraphLimits::new(nodes=1)) is Failed(Limit(Nodes)))
    }

    ReachabilityResult is Complete or Failed; RouteResult is Found, Unreachable or Failed. GraphFailure distinguishes InvalidEndpoint, DocumentMismatch, InvalidReference with its owner handle, Ambiguous with candidate nodes, Limit and InvalidLimits. A limit never reports unreachable or returns a partial result as complete. GraphLimits has positive inclusive node, edge, result and work bounds. Defaults are 100,000 nodes, 200,000 edges, 100,000 results and 1,000,000 work units.

    During graph construction, the edge bound counts indexed adjacency entries, including reverse entries and broken-edge markers. Work includes indexed resource records, reference candidates and conservative resource-record charges before imported resolution. Query edge bounds count selected adjacency entries inspected; work counts selection processing, expanded nodes and inspected entries. Selection is deduplicated once. Node/result bounds are checked before allocation; route results count path nodes. Each query has fresh state and its own budget. Document validation and traversal bounds also apply while building.

    ///|
    test "document traversal and graph construction code inventories" {
      assert_eq(@bpmn.traversal_diagnostic_codes,["bpmn/traversal-invalid-limits","bpmn/traversal-node-limit","bpmn/traversal-depth-limit","bpmn/traversal-token-limit"])
      assert_eq(@bpmn.graph_diagnostic_codes,["bpmn/graph-invalid-limits","bpmn/graph-work-limit","bpmn/graph-node-limit","bpmn/graph-edge-limit"])
    }

    Traversal diagnostics identify invalid limits, arena/metadata exhaustion, element-depth exhaustion or oversized names/values. Graph construction adds invalid-limit, work, node and adjacency-entry findings. It can also propagate the validation and traversal inventories documented above. All have error severity. Query failures use the typed alternatives described here.

    ReferenceResult.indexed_resources() exposes the immutable indexes in the explicit import closure. Each IndexedResource keeps its resource ID, document index and bounded record count. Adapters can reuse these indexes without reparsing or fetching resources. The record count includes attributes, content and namespace bindings, so repeated processing can be charged before allocation.

    EventSource

    source
    pub(open) trait EventSource {
      fn next(Self) -> TraversalEvent?
      fn skip_children(Self) -> Unit
      fn stop(Self) -> Unit
    }

    Visitor

    source
    pub(open) trait Visitor {
      fn enter(Self, NodeRef) -> Control = _
      fn visit_definitions(Self, Definitions, NodeRef) -> Control = _
      fn visit_process(Self, Process, NodeRef) -> Control = _
      fn visit_activity(Self, Activity, NodeRef) -> Control = _
      fn visit_event(Self, Event, NodeRef) -> Control = _
      fn visit_gateway(Self, Gateway, NodeRef) -> Control = _
      fn visit_sequence_flow(Self, SequenceFlow, NodeRef) -> Control = _
      fn visit_collaboration(Self, Collaboration, NodeRef) -> Control = _
      fn visit_participant(Self, Participant, NodeRef) -> Control = _
      fn visit_lane(Self, Lane, NodeRef) -> Control = _
      fn visit_choreography(Self, Choreography, NodeRef) -> Control = _
      fn visit_choreography_activity(Self, ChoreographyActivity, NodeRef) -> Control = _
      fn visit_conversation(Self, ConversationNode, NodeRef) -> Control = _
      fn visit_conversation_link(Self, ConversationLink, NodeRef) -> Control = _
      fn visit_extension(Self, XmlElement, NodeRef) -> Control = _
      fn visit_document(Self, NodeRef) -> Control = _
      fn visit_diagram_interchange(Self, NodeRef) -> Control = _
      fn visit_text(Self, NodeRef) -> Control = _
      fn visit_comment(Self, NodeRef) -> Control = _
      fn visit_processing_instruction(Self, NodeRef) -> Control = _
      fn visit_other(Self, NodeRef) -> Control = _
      fn leave(Self, NodeRef) -> Unit = _
    }

    Family methods have typed values and default to Continue. Other schema families remain inspectable through visit_other and NodeRef.element().

    WriteError

    source
    pub(all) suberror WriteError {
      Failed(ReadOnlyArray[Diagnostic])
    } derive(Eq, 
    Debug    )

    WriteError::equal

    source
    fn WriteError::equal(WriteError, WriteError) -> Bool

    WriteError::not_equal

    source
    fn WriteError::not_equal(x : WriteError, y : WriteError) -> Bool

    WriteError::to_repr

    source

    Activity

    source
    pub struct Activity {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tActivity.

    Activity::auditing

    source
    fn Activity::auditing(self : Activity) -> Field[Auditing]

    Activity::category_value_ref

    source
    fn Activity::category_value_ref(self : Activity) -> Field[ReadOnlyArray[Reference]]

    Activity::completion_quantity

    source
    fn Activity::completion_quantity(self : Activity) -> Field[ExactInteger]

    Activity::data_input_association

    source
    fn Activity::data_input_association(self : Activity) -> Field[ReadOnlyArray[DataInputAssociation]]

    Activity::data_output_association

    source
    fn Activity::data_output_association(self : Activity) -> Field[ReadOnlyArray[DataOutputAssociation]]

    Activity::default_

    source
    fn Activity::default_(self : Activity) -> Field[Reference]

    Activity::documentation

    source
    fn Activity::documentation(self : Activity) -> Field[ReadOnlyArray[Documentation]]

    Activity::equal

    source
    fn Activity::equal(Activity, Activity) -> Bool

    Activity::extension_elements

    source
    fn Activity::extension_elements(self : Activity) -> Field[ExtensionElements]

    Activity::from_element

    source
    fn Activity::from_element(element : Element) -> Activity?

    Activity::id

    source
    fn Activity::id(self : Activity) -> Field[String]

    Activity::incoming

    source
    fn Activity::incoming(self : Activity) -> Field[ReadOnlyArray[Reference]]

    Activity::io_specification

    source
    fn Activity::io_specification(self : Activity) -> Field[InputOutputSpecification]

    Activity::is_for_compensation

    source
    fn Activity::is_for_compensation(self : Activity) -> Field[Bool]

    Activity::loop_characteristics

    source
    fn Activity::loop_characteristics(self : Activity) -> Field[LoopCharacteristics]

    Activity::monitoring

    source
    fn Activity::monitoring(self : Activity) -> Field[Monitoring]

    Activity::name

    source
    fn Activity::name(self : Activity) -> Field[String]

    Activity::not_equal

    source
    fn Activity::not_equal(x : Activity, y : Activity) -> Bool

    Activity::outgoing

    source
    fn Activity::outgoing(self : Activity) -> Field[ReadOnlyArray[Reference]]

    Activity::property

    source
    fn Activity::property(self : Activity) -> Field[ReadOnlyArray[Property]]

    Activity::resource_role

    source
    fn Activity::resource_role(self : Activity) -> Field[ReadOnlyArray[ResourceRole]]

    Activity::start_quantity

    source
    fn Activity::start_quantity(self : Activity) -> Field[ExactInteger]

    Activity::to_repr

    source

    AdHocOrdering

    source
    pub(all) enum AdHocOrdering {
      Parallel
      Sequential
    } derive(Eq, 
    Debug    )

    Values of the pinned XSD type tAdHocOrdering.

    AdHocOrdering::equal

    source

    AdHocOrdering::not_equal

    source
    fn AdHocOrdering::not_equal(x : AdHocOrdering, y : AdHocOrdering) -> Bool

    AdHocOrdering::parse

    source
    fn AdHocOrdering::parse(token : String) -> AdHocOrdering?

    AdHocOrdering::to_repr

    source

    AdHocOrdering::token

    source
    fn AdHocOrdering::token(self : AdHocOrdering) -> String

    AdHocSubProcess

    source
    pub struct AdHocSubProcess {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tAdHocSubProcess.

    AdHocSubProcess::artifact

    source
    fn AdHocSubProcess::artifact(self : AdHocSubProcess) -> Field[ReadOnlyArray[Artifact]]

    AdHocSubProcess::auditing

    source

    AdHocSubProcess::cancel_remaining_instances

    source
    fn AdHocSubProcess::cancel_remaining_instances(self : AdHocSubProcess) -> Field[Bool]

    AdHocSubProcess::category_value_ref

    source
    fn AdHocSubProcess::category_value_ref(self : AdHocSubProcess) -> Field[ReadOnlyArray[Reference]]

    AdHocSubProcess::completion_condition

    source
    fn AdHocSubProcess::completion_condition(self : AdHocSubProcess) -> Field[Expression]

    AdHocSubProcess::completion_quantity

    source
    fn AdHocSubProcess::completion_quantity(self : AdHocSubProcess) -> Field[ExactInteger]

    AdHocSubProcess::data_input_association

    source
    fn AdHocSubProcess::data_input_association(self : AdHocSubProcess) -> Field[ReadOnlyArray[DataInputAssociation]]

    AdHocSubProcess::data_output_association

    source
    fn AdHocSubProcess::data_output_association(self : AdHocSubProcess) -> Field[ReadOnlyArray[DataOutputAssociation]]

    AdHocSubProcess::default_

    source

    AdHocSubProcess::documentation

    source
    fn AdHocSubProcess::documentation(self : AdHocSubProcess) -> Field[ReadOnlyArray[Documentation]]

    AdHocSubProcess::equal

    source

    AdHocSubProcess::extension_elements

    source
    fn AdHocSubProcess::extension_elements(self : AdHocSubProcess) -> Field[ExtensionElements]

    AdHocSubProcess::flow_element

    source
    fn AdHocSubProcess::flow_element(self : AdHocSubProcess) -> Field[ReadOnlyArray[FlowElement]]

    AdHocSubProcess::from_element

    source
    fn AdHocSubProcess::from_element(element : Element) -> AdHocSubProcess?

    AdHocSubProcess::id

    source
    fn AdHocSubProcess::id(self : AdHocSubProcess) -> Field[String]

    AdHocSubProcess::incoming

    source
    fn AdHocSubProcess::incoming(self : AdHocSubProcess) -> Field[ReadOnlyArray[Reference]]

    AdHocSubProcess::io_specification

    source

    AdHocSubProcess::is_for_compensation

    source
    fn AdHocSubProcess::is_for_compensation(self : AdHocSubProcess) -> Field[Bool]

    AdHocSubProcess::lane_set

    source
    fn AdHocSubProcess::lane_set(self : AdHocSubProcess) -> Field[ReadOnlyArray[LaneSet]]

    AdHocSubProcess::loop_characteristics

    source
    fn AdHocSubProcess::loop_characteristics(self : AdHocSubProcess) -> Field[LoopCharacteristics]

    AdHocSubProcess::monitoring

    source
    fn AdHocSubProcess::monitoring(self : AdHocSubProcess) -> Field[Monitoring]

    AdHocSubProcess::name

    source
    fn AdHocSubProcess::name(self : AdHocSubProcess) -> Field[String]

    AdHocSubProcess::new

    source
    fn AdHocSubProcess::new(id? : String, name? : String, is_for_compensation? : Bool, start_quantity? : ExactInteger, completion_quantity? : ExactInteger, default_? : Reference, triggered_by_event? : Bool, cancel_remaining_instances? : Bool, ordering? : AdHocOrdering, contents? : ArrayView[Content]) -> AdHocSubProcess

    AdHocSubProcess::not_equal

    source
    fn AdHocSubProcess::not_equal(x : AdHocSubProcess, y : AdHocSubProcess) -> Bool

    AdHocSubProcess::ordering

    source

    AdHocSubProcess::outgoing

    source
    fn AdHocSubProcess::outgoing(self : AdHocSubProcess) -> Field[ReadOnlyArray[Reference]]

    AdHocSubProcess::property

    source
    fn AdHocSubProcess::property(self : AdHocSubProcess) -> Field[ReadOnlyArray[Property]]

    AdHocSubProcess::resource_role

    source
    fn AdHocSubProcess::resource_role(self : AdHocSubProcess) -> Field[ReadOnlyArray[ResourceRole]]

    AdHocSubProcess::start_quantity

    source
    fn AdHocSubProcess::start_quantity(self : AdHocSubProcess) -> Field[ExactInteger]

    AdHocSubProcess::to_repr

    source

    AdHocSubProcess::triggered_by_event

    source
    fn AdHocSubProcess::triggered_by_event(self : AdHocSubProcess) -> Field[Bool]

    AnonymousTImplementation78

    source
    pub(all) enum AnonymousTImplementation78 {
      Unspecified
      WebService
    } derive(Eq, 
    Debug    )

    Values of the pinned XSD type Anonymous_tImplementation_78.

    AnonymousTImplementation78::equal

    source

    AnonymousTImplementation78::not_equal

    source

    AnonymousTImplementation78::parse

    source

    AnonymousTImplementation78::to_repr

    source

    AnonymousTImplementation78::token

    source

    AnonymousTTransactionMethod144

    source
    pub(all) enum AnonymousTTransactionMethod144 {
      Compensate
      Image
      Store
    } derive(Eq, 
    Debug    )

    Values of the pinned XSD type Anonymous_tTransactionMethod_144.

    AnonymousTTransactionMethod144::equal

    source

    AnonymousTTransactionMethod144::not_equal

    source

    AnonymousTTransactionMethod144::parse

    source

    AnonymousTTransactionMethod144::to_repr

    source

    AnonymousTTransactionMethod144::token

    source

    Artifact

    source
    pub struct Artifact {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tArtifact.

    Artifact::documentation

    source
    fn Artifact::documentation(self : Artifact) -> Field[ReadOnlyArray[Documentation]]

    Artifact::equal

    source
    fn Artifact::equal(Artifact, Artifact) -> Bool

    Artifact::extension_elements

    source
    fn Artifact::extension_elements(self : Artifact) -> Field[ExtensionElements]

    Artifact::from_element

    source
    fn Artifact::from_element(element : Element) -> Artifact?

    Artifact::id

    source
    fn Artifact::id(self : Artifact) -> Field[String]

    Artifact::not_equal

    source
    fn Artifact::not_equal(x : Artifact, y : Artifact) -> Bool

    Artifact::to_repr

    source

    Assignment

    source
    pub struct Assignment {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tAssignment.

    Assignment::documentation

    source
    fn Assignment::documentation(self : Assignment) -> Field[ReadOnlyArray[Documentation]]

    Assignment::equal

    source
    fn Assignment::equal(Assignment, Assignment) -> Bool

    Assignment::extension_elements

    source
    fn Assignment::extension_elements(self : Assignment) -> Field[ExtensionElements]

    Assignment::from

    source
    fn Assignment::from(self : Assignment) -> Field[Expression]

    Assignment::from_element

    source
    fn Assignment::from_element(element : Element) -> Assignment?

    Assignment::id

    source
    fn Assignment::id(self : Assignment) -> Field[String]

    Assignment::new

    source
    fn Assignment::new(id? : String, contents? : ArrayView[Content]) -> Assignment

    Assignment::not_equal

    source
    fn Assignment::not_equal(x : Assignment, y : Assignment) -> Bool

    Assignment::to

    source

    Assignment::to_repr

    source

    Association

    source
    pub struct Association {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tAssociation.

    Association::association_direction

    source
    fn Association::association_direction(self : Association) -> Field[AssociationDirection]

    Association::documentation

    source
    fn Association::documentation(self : Association) -> Field[ReadOnlyArray[Documentation]]

    Association::equal

    source
    fn Association::equal(Association, Association) -> Bool

    Association::extension_elements

    source
    fn Association::extension_elements(self : Association) -> Field[ExtensionElements]

    Association::from_element

    source
    fn Association::from_element(element : Element) -> Association?

    Association::id

    source
    fn Association::id(self : Association) -> Field[String]

    Association::new

    source
    fn Association::new(id? : String, source_ref? : Reference, target_ref? : Reference, association_direction? : AssociationDirection, contents? : ArrayView[Content]) -> Association

    Association::not_equal

    source
    fn Association::not_equal(x : Association, y : Association) -> Bool

    Association::source_ref

    source
    fn Association::source_ref(self : Association) -> Field[Reference]

    Association::target_ref

    source
    fn Association::target_ref(self : Association) -> Field[Reference]

    Association::to_repr

    source

    AssociationDirection

    source
    pub(all) enum AssociationDirection {
      None
      One
      Both
    } derive(Eq, 
    Debug    )

    Values of the pinned XSD type tAssociationDirection.

    AssociationDirection::equal

    source

    AssociationDirection::not_equal

    source

    AssociationDirection::parse

    source
    fn AssociationDirection::parse(token : String) -> AssociationDirection?

    AssociationDirection::to_repr

    source

    AssociationDirection::token

    source
    fn AssociationDirection::token(self : AssociationDirection) -> String

    Attribute

    source
    pub struct Attribute {
      name : ExpandedName?
      raw_name : String
      value : Scalar
      span : Span?
      // private fields
    } derive(Eq, 
    Debug    )

    Attribute::equal

    source
    fn Attribute::equal(Attribute, Attribute) -> Bool

    Attribute::location

    source
    fn Attribute::location(self : Attribute) -> Location?

    Attribute::new

    source
    fn Attribute::new(name : ExpandedName, value : Scalar) -> Attribute

    Attribute::not_equal

    source
    fn Attribute::not_equal(x : Attribute, y : Attribute) -> Bool

    Attribute::to_repr

    source

    Auditing

    source
    pub struct Auditing {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tAuditing.

    Auditing::documentation

    source
    fn Auditing::documentation(self : Auditing) -> Field[ReadOnlyArray[Documentation]]

    Auditing::equal

    source
    fn Auditing::equal(Auditing, Auditing) -> Bool

    Auditing::extension_elements

    source
    fn Auditing::extension_elements(self : Auditing) -> Field[ExtensionElements]

    Auditing::from_element

    source
    fn Auditing::from_element(element : Element) -> Auditing?

    Auditing::id

    source
    fn Auditing::id(self : Auditing) -> Field[String]

    Auditing::new

    source
    fn Auditing::new(id? : String, contents? : ArrayView[Content]) -> Auditing

    Auditing::not_equal

    source
    fn Auditing::not_equal(x : Auditing, y : Auditing) -> Bool

    Auditing::to_repr

    source

    BaseElement

    source
    pub struct BaseElement {
      element : Element
    } derive(Eq, 
    Debug    )

    A typed view over a concrete element derived from the abstract base type.

    BaseElement::documentation

    source
    fn BaseElement::documentation(self : BaseElement) -> ReadOnlyArray[Documentation]

    BaseElement::equal

    source
    fn BaseElement::equal(BaseElement, BaseElement) -> Bool

    BaseElement::extension_elements

    source
    fn BaseElement::extension_elements(self : BaseElement) -> Element?

    BaseElement::from_element

    source
    fn BaseElement::from_element(element : Element) -> BaseElement?

    BaseElement::id

    source
    fn BaseElement::id(self : BaseElement) -> Field[String]

    BaseElement::not_equal

    source
    fn BaseElement::not_equal(x : BaseElement, y : BaseElement) -> Bool

    BaseElement::to_repr

    source

    BaseElementWithMixedContent

    source
    pub struct BaseElementWithMixedContent {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tBaseElementWithMixedContent.

    BaseElementWithMixedContent::documentation

    source
    fn BaseElementWithMixedContent::documentation(self : BaseElementWithMixedContent) -> Field[ReadOnlyArray[Documentation]]

    BaseElementWithMixedContent::equal

    source

    BaseElementWithMixedContent::extension_elements

    source

    BaseElementWithMixedContent::from_element

    source

    BaseElementWithMixedContent::id

    source

    BaseElementWithMixedContent::not_equal

    source

    BaseElementWithMixedContent::to_repr

    source

    BoundaryEvent

    source
    pub struct BoundaryEvent {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tBoundaryEvent.

    BoundaryEvent::attached_to_ref

    source
    fn BoundaryEvent::attached_to_ref(self : BoundaryEvent) -> Field[Reference]

    BoundaryEvent::auditing

    source
    fn BoundaryEvent::auditing(self : BoundaryEvent) -> Field[Auditing]

    BoundaryEvent::cancel_activity

    source
    fn BoundaryEvent::cancel_activity(self : BoundaryEvent) -> Field[Bool]

    BoundaryEvent::category_value_ref

    source
    fn BoundaryEvent::category_value_ref(self : BoundaryEvent) -> Field[ReadOnlyArray[Reference]]

    BoundaryEvent::data_output

    source
    fn BoundaryEvent::data_output(self : BoundaryEvent) -> Field[ReadOnlyArray[DataOutput]]

    BoundaryEvent::data_output_association

    source
    fn BoundaryEvent::data_output_association(self : BoundaryEvent) -> Field[ReadOnlyArray[DataOutputAssociation]]

    BoundaryEvent::documentation

    source
    fn BoundaryEvent::documentation(self : BoundaryEvent) -> Field[ReadOnlyArray[Documentation]]

    BoundaryEvent::equal

    source

    BoundaryEvent::event_definition

    source
    fn BoundaryEvent::event_definition(self : BoundaryEvent) -> Field[ReadOnlyArray[EventDefinition]]

    BoundaryEvent::event_definition_ref

    source
    fn BoundaryEvent::event_definition_ref(self : BoundaryEvent) -> Field[ReadOnlyArray[Reference]]

    BoundaryEvent::extension_elements

    source
    fn BoundaryEvent::extension_elements(self : BoundaryEvent) -> Field[ExtensionElements]

    BoundaryEvent::from_element

    source
    fn BoundaryEvent::from_element(element : Element) -> BoundaryEvent?

    BoundaryEvent::id

    source
    fn BoundaryEvent::id(self : BoundaryEvent) -> Field[String]

    BoundaryEvent::incoming

    source
    fn BoundaryEvent::incoming(self : BoundaryEvent) -> Field[ReadOnlyArray[Reference]]

    BoundaryEvent::monitoring

    source
    fn BoundaryEvent::monitoring(self : BoundaryEvent) -> Field[Monitoring]

    BoundaryEvent::name

    source
    fn BoundaryEvent::name(self : BoundaryEvent) -> Field[String]

    BoundaryEvent::new

    source
    fn BoundaryEvent::new(id? : String, name? : String, parallel_multiple? : Bool, cancel_activity? : Bool, attached_to_ref? : Reference, contents? : ArrayView[Content]) -> BoundaryEvent

    BoundaryEvent::not_equal

    source
    fn BoundaryEvent::not_equal(x : BoundaryEvent, y : BoundaryEvent) -> Bool

    BoundaryEvent::outgoing

    source
    fn BoundaryEvent::outgoing(self : BoundaryEvent) -> Field[ReadOnlyArray[Reference]]

    BoundaryEvent::output_set

    source
    fn BoundaryEvent::output_set(self : BoundaryEvent) -> Field[OutputSet]

    BoundaryEvent::parallel_multiple

    source
    fn BoundaryEvent::parallel_multiple(self : BoundaryEvent) -> Field[Bool]

    BoundaryEvent::property

    source
    fn BoundaryEvent::property(self : BoundaryEvent) -> Field[ReadOnlyArray[Property]]

    BoundaryEvent::to_repr

    source

    BpmnDiagram

    source
    pub struct BpmnDiagram {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema BPMNDiagram.

    BpmnDiagram::bpmn_label_style

    source
    fn BpmnDiagram::bpmn_label_style(self : BpmnDiagram) -> Field[ReadOnlyArray[BpmnLabelStyle]]

    BpmnDiagram::bpmn_plane

    source
    fn BpmnDiagram::bpmn_plane(self : BpmnDiagram) -> Field[BpmnPlane]

    BpmnDiagram::documentation

    source
    fn BpmnDiagram::documentation(self : BpmnDiagram) -> Field[String]

    BpmnDiagram::equal

    source
    fn BpmnDiagram::equal(BpmnDiagram, BpmnDiagram) -> Bool

    BpmnDiagram::from_element

    source
    fn BpmnDiagram::from_element(element : Element) -> BpmnDiagram?

    BpmnDiagram::id

    source
    fn BpmnDiagram::id(self : BpmnDiagram) -> Field[String]

    BpmnDiagram::name

    source
    fn BpmnDiagram::name(self : BpmnDiagram) -> Field[String]

    BpmnDiagram::new

    source
    fn BpmnDiagram::new(name? : String, documentation? : String, resolution? : ExactNumber, id? : String, contents? : ArrayView[Content]) -> BpmnDiagram

    BpmnDiagram::not_equal

    source
    fn BpmnDiagram::not_equal(x : BpmnDiagram, y : BpmnDiagram) -> Bool

    BpmnDiagram::resolution

    source
    fn BpmnDiagram::resolution(self : BpmnDiagram) -> Field[ExactNumber]

    BpmnDiagram::to_repr

    source

    BpmnEdge

    source
    pub struct BpmnEdge {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema BPMNEdge.

    BpmnEdge::bpmn_element

    source
    fn BpmnEdge::bpmn_element(self : BpmnEdge) -> Field[Reference]

    BpmnEdge::bpmn_label

    source
    fn BpmnEdge::bpmn_label(self : BpmnEdge) -> Field[BpmnLabel]

    BpmnEdge::equal

    source
    fn BpmnEdge::equal(BpmnEdge, BpmnEdge) -> Bool

    BpmnEdge::extension

    source

    BpmnEdge::from_element

    source
    fn BpmnEdge::from_element(element : Element) -> BpmnEdge?

    BpmnEdge::id

    source
    fn BpmnEdge::id(self : BpmnEdge) -> Field[String]

    BpmnEdge::message_visible_kind

    source
    fn BpmnEdge::message_visible_kind(self : BpmnEdge) -> Field[BpmnMessageVisibleKind]

    BpmnEdge::new

    source
    fn BpmnEdge::new(id? : String, bpmn_element? : Reference, source_element? : Reference, target_element? : Reference, message_visible_kind? : BpmnMessageVisibleKind, contents? : ArrayView[Content]) -> BpmnEdge

    BpmnEdge::not_equal

    source
    fn BpmnEdge::not_equal(x : BpmnEdge, y : BpmnEdge) -> Bool

    BpmnEdge::source_element

    source
    fn BpmnEdge::source_element(self : BpmnEdge) -> Field[Reference]

    BpmnEdge::target_element

    source
    fn BpmnEdge::target_element(self : BpmnEdge) -> Field[Reference]

    BpmnEdge::to_repr

    source

    BpmnEdge::waypoint

    source
    fn BpmnEdge::waypoint(self : BpmnEdge) -> Field[ReadOnlyArray[DcPoint]]

    BpmnEnum

    source
    pub(all) enum BpmnEnum {
      BpmnParticipantBandKind(BpmnParticipantBandKind)
      BpmnMessageVisibleKind(BpmnMessageVisibleKind)
      AdHocOrdering(AdHocOrdering)
      AssociationDirection(AssociationDirection)
      ChoreographyLoopType(ChoreographyLoopType)
      EventBasedGatewayType(EventBasedGatewayType)
      GatewayDirection(GatewayDirection)
      Implementation(Implementation)
      AnonymousTImplementation78(AnonymousTImplementation78)
      ItemKind(ItemKind)
      MultiInstanceFlowCondition(MultiInstanceFlowCondition)
      ProcessType(ProcessType)
      RelationshipDirection(RelationshipDirection)
      TransactionMethod(TransactionMethod)
      AnonymousTTransactionMethod144(AnonymousTTransactionMethod144)
    } derive(Eq, 
    Debug    )

    Typed alternatives retain the identity of each normative enumeration.

    BpmnEnum::equal

    source
    fn BpmnEnum::equal(BpmnEnum, BpmnEnum) -> Bool

    BpmnEnum::not_equal

    source
    fn BpmnEnum::not_equal(x : BpmnEnum, y : BpmnEnum) -> Bool

    BpmnEnum::to_repr

    source

    BpmnEnum::token

    source
    fn BpmnEnum::token(self : BpmnEnum) -> String

    BpmnEnum::type_id

    source
    fn BpmnEnum::type_id(self : BpmnEnum) -> TypeId

    BpmnError

    source
    pub struct BpmnError {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tError.

    BpmnError::documentation

    source
    fn BpmnError::documentation(self : BpmnError) -> Field[ReadOnlyArray[Documentation]]

    BpmnError::equal

    source
    fn BpmnError::equal(BpmnError, BpmnError) -> Bool

    BpmnError::error_code

    source
    fn BpmnError::error_code(self : BpmnError) -> Field[String]

    BpmnError::extension_elements

    source
    fn BpmnError::extension_elements(self : BpmnError) -> Field[ExtensionElements]

    BpmnError::from_element

    source
    fn BpmnError::from_element(element : Element) -> BpmnError?

    BpmnError::id

    source
    fn BpmnError::id(self : BpmnError) -> Field[String]

    BpmnError::name

    source
    fn BpmnError::name(self : BpmnError) -> Field[String]

    BpmnError::new

    source
    fn BpmnError::new(id? : String, name? : String, error_code? : String, structure_ref? : Reference, contents? : ArrayView[Content]) -> BpmnError

    BpmnError::not_equal

    source
    fn BpmnError::not_equal(x : BpmnError, y : BpmnError) -> Bool

    BpmnError::structure_ref

    source
    fn BpmnError::structure_ref(self : BpmnError) -> Field[Reference]

    BpmnError::to_repr

    source

    BpmnLabel

    source
    pub struct BpmnLabel {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema BPMNLabel.

    BpmnLabel::bounds

    source
    fn BpmnLabel::bounds(self : BpmnLabel) -> Field[DcBounds]

    BpmnLabel::equal

    source
    fn BpmnLabel::equal(BpmnLabel, BpmnLabel) -> Bool

    BpmnLabel::extension

    source

    BpmnLabel::from_element

    source
    fn BpmnLabel::from_element(element : Element) -> BpmnLabel?

    BpmnLabel::id

    source
    fn BpmnLabel::id(self : BpmnLabel) -> Field[String]

    BpmnLabel::label_style

    source
    fn BpmnLabel::label_style(self : BpmnLabel) -> Field[Reference]

    BpmnLabel::new

    source
    fn BpmnLabel::new(id? : String, label_style? : Reference, contents? : ArrayView[Content]) -> BpmnLabel

    BpmnLabel::not_equal

    source
    fn BpmnLabel::not_equal(x : BpmnLabel, y : BpmnLabel) -> Bool

    BpmnLabel::to_repr

    source

    BpmnLabelStyle

    source
    pub struct BpmnLabelStyle {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema BPMNLabelStyle.

    BpmnLabelStyle::equal

    source

    BpmnLabelStyle::font

    source

    BpmnLabelStyle::from_element

    source
    fn BpmnLabelStyle::from_element(element : Element) -> BpmnLabelStyle?

    BpmnLabelStyle::id

    source
    fn BpmnLabelStyle::id(self : BpmnLabelStyle) -> Field[String]

    BpmnLabelStyle::new

    source
    fn BpmnLabelStyle::new(id? : String, contents? : ArrayView[Content]) -> BpmnLabelStyle

    BpmnLabelStyle::not_equal

    source
    fn BpmnLabelStyle::not_equal(x : BpmnLabelStyle, y : BpmnLabelStyle) -> Bool

    BpmnLabelStyle::to_repr

    source

    BpmnMessageVisibleKind

    source
    pub(all) enum BpmnMessageVisibleKind {
      Initiating
      NonInitiating
    } derive(Eq, 
    Debug    )

    Values of the pinned XSD type MessageVisibleKind.

    BpmnMessageVisibleKind::equal

    source

    BpmnMessageVisibleKind::not_equal

    source

    BpmnMessageVisibleKind::parse

    source
    fn BpmnMessageVisibleKind::parse(token : String) -> BpmnMessageVisibleKind?

    BpmnMessageVisibleKind::to_repr

    source

    BpmnMessageVisibleKind::token

    source

    BpmnParticipantBandKind

    source
    pub(all) enum BpmnParticipantBandKind {
      TopInitiating
      MiddleInitiating
      BottomInitiating
      TopNonInitiating
      MiddleNonInitiating
      BottomNonInitiating
    } derive(Eq, 
    Debug    )

    Values of the pinned XSD type ParticipantBandKind.

    BpmnParticipantBandKind::equal

    source

    BpmnParticipantBandKind::not_equal

    source

    BpmnParticipantBandKind::parse

    source
    fn BpmnParticipantBandKind::parse(token : String) -> BpmnParticipantBandKind?

    BpmnParticipantBandKind::to_repr

    source

    BpmnParticipantBandKind::token

    source

    BpmnPlane

    source
    pub struct BpmnPlane {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema BPMNPlane.

    BpmnPlane::bpmn_element

    source
    fn BpmnPlane::bpmn_element(self : BpmnPlane) -> Field[Reference]

    BpmnPlane::diagram_element

    source
    fn BpmnPlane::diagram_element(self : BpmnPlane) -> Field[ReadOnlyArray[DiDiagramElement]]

    BpmnPlane::equal

    source
    fn BpmnPlane::equal(BpmnPlane, BpmnPlane) -> Bool

    BpmnPlane::extension

    source

    BpmnPlane::from_element

    source
    fn BpmnPlane::from_element(element : Element) -> BpmnPlane?

    BpmnPlane::id

    source
    fn BpmnPlane::id(self : BpmnPlane) -> Field[String]

    BpmnPlane::new

    source
    fn BpmnPlane::new(id? : String, bpmn_element? : Reference, contents? : ArrayView[Content]) -> BpmnPlane

    BpmnPlane::not_equal

    source
    fn BpmnPlane::not_equal(x : BpmnPlane, y : BpmnPlane) -> Bool

    BpmnPlane::to_repr

    source

    BpmnShape

    source
    pub struct BpmnShape {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema BPMNShape.

    BpmnShape::bounds

    source
    fn BpmnShape::bounds(self : BpmnShape) -> Field[DcBounds]

    BpmnShape::bpmn_element

    source
    fn BpmnShape::bpmn_element(self : BpmnShape) -> Field[Reference]

    BpmnShape::bpmn_label

    source
    fn BpmnShape::bpmn_label(self : BpmnShape) -> Field[BpmnLabel]

    BpmnShape::choreography_activity_shape

    source
    fn BpmnShape::choreography_activity_shape(self : BpmnShape) -> Field[Reference]

    BpmnShape::equal

    source
    fn BpmnShape::equal(BpmnShape, BpmnShape) -> Bool

    BpmnShape::extension

    source

    BpmnShape::from_element

    source
    fn BpmnShape::from_element(element : Element) -> BpmnShape?

    BpmnShape::id

    source
    fn BpmnShape::id(self : BpmnShape) -> Field[String]

    BpmnShape::is_expanded

    source
    fn BpmnShape::is_expanded(self : BpmnShape) -> Field[Bool]

    BpmnShape::is_horizontal

    source
    fn BpmnShape::is_horizontal(self : BpmnShape) -> Field[Bool]

    BpmnShape::is_marker_visible

    source
    fn BpmnShape::is_marker_visible(self : BpmnShape) -> Field[Bool]

    BpmnShape::is_message_visible

    source
    fn BpmnShape::is_message_visible(self : BpmnShape) -> Field[Bool]

    BpmnShape::new

    source
    fn BpmnShape::new(id? : String, bpmn_element? : Reference, is_horizontal? : Bool, is_expanded? : Bool, is_marker_visible? : Bool, is_message_visible? : Bool, participant_band_kind? : BpmnParticipantBandKind, choreography_activity_shape? : Reference, contents? : ArrayView[Content]) -> BpmnShape

    BpmnShape::not_equal

    source
    fn BpmnShape::not_equal(x : BpmnShape, y : BpmnShape) -> Bool

    BpmnShape::participant_band_kind

    source
    fn BpmnShape::participant_band_kind(self : BpmnShape) -> Field[BpmnParticipantBandKind]

    BpmnShape::to_repr

    source

    BusinessRuleTask

    source
    pub struct BusinessRuleTask {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tBusinessRuleTask.

    BusinessRuleTask::auditing

    source

    BusinessRuleTask::category_value_ref

    source
    fn BusinessRuleTask::category_value_ref(self : BusinessRuleTask) -> Field[ReadOnlyArray[Reference]]

    BusinessRuleTask::completion_quantity

    source
    fn BusinessRuleTask::completion_quantity(self : BusinessRuleTask) -> Field[ExactInteger]

    BusinessRuleTask::data_input_association

    source
    fn BusinessRuleTask::data_input_association(self : BusinessRuleTask) -> Field[ReadOnlyArray[DataInputAssociation]]

    BusinessRuleTask::data_output_association

    source
    fn BusinessRuleTask::data_output_association(self : BusinessRuleTask) -> Field[ReadOnlyArray[DataOutputAssociation]]

    BusinessRuleTask::default_

    source

    BusinessRuleTask::documentation

    source
    fn BusinessRuleTask::documentation(self : BusinessRuleTask) -> Field[ReadOnlyArray[Documentation]]

    BusinessRuleTask::equal

    source

    BusinessRuleTask::extension_elements

    source
    fn BusinessRuleTask::extension_elements(self : BusinessRuleTask) -> Field[ExtensionElements]

    BusinessRuleTask::from_element

    source
    fn BusinessRuleTask::from_element(element : Element) -> BusinessRuleTask?

    BusinessRuleTask::id

    source
    fn BusinessRuleTask::id(self : BusinessRuleTask) -> Field[String]

    BusinessRuleTask::implementation

    source
    fn BusinessRuleTask::implementation(self : BusinessRuleTask) -> Field[Implementation]

    BusinessRuleTask::incoming

    source
    fn BusinessRuleTask::incoming(self : BusinessRuleTask) -> Field[ReadOnlyArray[Reference]]

    BusinessRuleTask::io_specification

    source

    BusinessRuleTask::is_for_compensation

    source
    fn BusinessRuleTask::is_for_compensation(self : BusinessRuleTask) -> Field[Bool]

    BusinessRuleTask::loop_characteristics

    source
    fn BusinessRuleTask::loop_characteristics(self : BusinessRuleTask) -> Field[LoopCharacteristics]

    BusinessRuleTask::monitoring

    source

    BusinessRuleTask::name

    source
    fn BusinessRuleTask::name(self : BusinessRuleTask) -> Field[String]

    BusinessRuleTask::new

    source
    fn BusinessRuleTask::new(id? : String, name? : String, is_for_compensation? : Bool, start_quantity? : ExactInteger, completion_quantity? : ExactInteger, default_? : Reference, implementation? : Implementation, contents? : ArrayView[Content]) -> BusinessRuleTask

    BusinessRuleTask::not_equal

    source
    fn BusinessRuleTask::not_equal(x : BusinessRuleTask, y : BusinessRuleTask) -> Bool

    BusinessRuleTask::outgoing

    source
    fn BusinessRuleTask::outgoing(self : BusinessRuleTask) -> Field[ReadOnlyArray[Reference]]

    BusinessRuleTask::property

    source
    fn BusinessRuleTask::property(self : BusinessRuleTask) -> Field[ReadOnlyArray[Property]]

    BusinessRuleTask::resource_role

    source
    fn BusinessRuleTask::resource_role(self : BusinessRuleTask) -> Field[ReadOnlyArray[ResourceRole]]

    BusinessRuleTask::start_quantity

    source
    fn BusinessRuleTask::start_quantity(self : BusinessRuleTask) -> Field[ExactInteger]

    BusinessRuleTask::to_repr

    source

    CallActivity

    source
    pub struct CallActivity {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tCallActivity.

    CallActivity::auditing

    source
    fn CallActivity::auditing(self : CallActivity) -> Field[Auditing]

    CallActivity::called_element

    source
    fn CallActivity::called_element(self : CallActivity) -> Field[Reference]

    CallActivity::category_value_ref

    source
    fn CallActivity::category_value_ref(self : CallActivity) -> Field[ReadOnlyArray[Reference]]

    CallActivity::completion_quantity

    source
    fn CallActivity::completion_quantity(self : CallActivity) -> Field[ExactInteger]

    CallActivity::data_input_association

    source
    fn CallActivity::data_input_association(self : CallActivity) -> Field[ReadOnlyArray[DataInputAssociation]]

    CallActivity::data_output_association

    source
    fn CallActivity::data_output_association(self : CallActivity) -> Field[ReadOnlyArray[DataOutputAssociation]]

    CallActivity::default_

    source
    fn CallActivity::default_(self : CallActivity) -> Field[Reference]

    CallActivity::documentation

    source
    fn CallActivity::documentation(self : CallActivity) -> Field[ReadOnlyArray[Documentation]]

    CallActivity::equal

    source

    CallActivity::extension_elements

    source
    fn CallActivity::extension_elements(self : CallActivity) -> Field[ExtensionElements]

    CallActivity::from_element

    source
    fn CallActivity::from_element(element : Element) -> CallActivity?

    CallActivity::id

    source
    fn CallActivity::id(self : CallActivity) -> Field[String]

    CallActivity::incoming

    source
    fn CallActivity::incoming(self : CallActivity) -> Field[ReadOnlyArray[Reference]]

    CallActivity::io_specification

    source
    fn CallActivity::io_specification(self : CallActivity) -> Field[InputOutputSpecification]

    CallActivity::is_for_compensation

    source
    fn CallActivity::is_for_compensation(self : CallActivity) -> Field[Bool]

    CallActivity::loop_characteristics

    source
    fn CallActivity::loop_characteristics(self : CallActivity) -> Field[LoopCharacteristics]

    CallActivity::monitoring

    source
    fn CallActivity::monitoring(self : CallActivity) -> Field[Monitoring]

    CallActivity::name

    source
    fn CallActivity::name(self : CallActivity) -> Field[String]

    CallActivity::new

    source
    fn CallActivity::new(id? : String, name? : String, is_for_compensation? : Bool, start_quantity? : ExactInteger, completion_quantity? : ExactInteger, default_? : Reference, called_element? : Reference, contents? : ArrayView[Content]) -> CallActivity

    CallActivity::not_equal

    source
    fn CallActivity::not_equal(x : CallActivity, y : CallActivity) -> Bool

    CallActivity::outgoing

    source
    fn CallActivity::outgoing(self : CallActivity) -> Field[ReadOnlyArray[Reference]]

    CallActivity::property

    source
    fn CallActivity::property(self : CallActivity) -> Field[ReadOnlyArray[Property]]

    CallActivity::resource_role

    source
    fn CallActivity::resource_role(self : CallActivity) -> Field[ReadOnlyArray[ResourceRole]]

    CallActivity::start_quantity

    source
    fn CallActivity::start_quantity(self : CallActivity) -> Field[ExactInteger]

    CallActivity::to_repr

    source

    CallChoreography

    source
    pub struct CallChoreography {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tCallChoreography.

    CallChoreography::auditing

    source

    CallChoreography::called_choreography_ref

    source
    fn CallChoreography::called_choreography_ref(self : CallChoreography) -> Field[Reference]

    CallChoreography::category_value_ref

    source
    fn CallChoreography::category_value_ref(self : CallChoreography) -> Field[ReadOnlyArray[Reference]]

    CallChoreography::correlation_key

    source
    fn CallChoreography::correlation_key(self : CallChoreography) -> Field[ReadOnlyArray[CorrelationKey]]

    CallChoreography::documentation

    source
    fn CallChoreography::documentation(self : CallChoreography) -> Field[ReadOnlyArray[Documentation]]

    CallChoreography::equal

    source

    CallChoreography::extension_elements

    source
    fn CallChoreography::extension_elements(self : CallChoreography) -> Field[ExtensionElements]

    CallChoreography::from_element

    source
    fn CallChoreography::from_element(element : Element) -> CallChoreography?

    CallChoreography::id

    source
    fn CallChoreography::id(self : CallChoreography) -> Field[String]

    CallChoreography::incoming

    source
    fn CallChoreography::incoming(self : CallChoreography) -> Field[ReadOnlyArray[Reference]]

    CallChoreography::initiating_participant_ref

    source
    fn CallChoreography::initiating_participant_ref(self : CallChoreography) -> Field[Reference]

    CallChoreography::loop_type

    source

    CallChoreography::monitoring

    source

    CallChoreography::name

    source
    fn CallChoreography::name(self : CallChoreography) -> Field[String]

    CallChoreography::new

    source
    fn CallChoreography::new(id? : String, name? : String, initiating_participant_ref? : Reference, loop_type? : ChoreographyLoopType, called_choreography_ref? : Reference, contents? : ArrayView[Content]) -> CallChoreography

    CallChoreography::not_equal

    source
    fn CallChoreography::not_equal(x : CallChoreography, y : CallChoreography) -> Bool

    CallChoreography::outgoing

    source
    fn CallChoreography::outgoing(self : CallChoreography) -> Field[ReadOnlyArray[Reference]]

    CallChoreography::participant_association

    source
    fn CallChoreography::participant_association(self : CallChoreography) -> Field[ReadOnlyArray[ParticipantAssociation]]

    CallChoreography::participant_ref

    source
    fn CallChoreography::participant_ref(self : CallChoreography) -> Field[ReadOnlyArray[Reference]]

    CallChoreography::to_repr

    source

    CallConversation

    source
    pub struct CallConversation {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tCallConversation.

    CallConversation::called_collaboration_ref

    source
    fn CallConversation::called_collaboration_ref(self : CallConversation) -> Field[Reference]

    CallConversation::correlation_key

    source
    fn CallConversation::correlation_key(self : CallConversation) -> Field[ReadOnlyArray[CorrelationKey]]

    CallConversation::documentation

    source
    fn CallConversation::documentation(self : CallConversation) -> Field[ReadOnlyArray[Documentation]]

    CallConversation::equal

    source

    CallConversation::extension_elements

    source
    fn CallConversation::extension_elements(self : CallConversation) -> Field[ExtensionElements]

    CallConversation::from_element

    source
    fn CallConversation::from_element(element : Element) -> CallConversation?

    CallConversation::id

    source
    fn CallConversation::id(self : CallConversation) -> Field[String]

    CallConversation::message_flow_ref

    source
    fn CallConversation::message_flow_ref(self : CallConversation) -> Field[ReadOnlyArray[Reference]]

    CallConversation::name

    source
    fn CallConversation::name(self : CallConversation) -> Field[String]

    CallConversation::new

    source
    fn CallConversation::new(id? : String, name? : String, called_collaboration_ref? : Reference, contents? : ArrayView[Content]) -> CallConversation

    CallConversation::not_equal

    source
    fn CallConversation::not_equal(x : CallConversation, y : CallConversation) -> Bool

    CallConversation::participant_association

    source
    fn CallConversation::participant_association(self : CallConversation) -> Field[ReadOnlyArray[ParticipantAssociation]]

    CallConversation::participant_ref

    source
    fn CallConversation::participant_ref(self : CallConversation) -> Field[ReadOnlyArray[Reference]]

    CallConversation::to_repr

    source

    CallableElement

    source
    pub struct CallableElement {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tCallableElement.

    CallableElement::documentation

    source
    fn CallableElement::documentation(self : CallableElement) -> Field[ReadOnlyArray[Documentation]]

    CallableElement::equal

    source

    CallableElement::extension_elements

    source
    fn CallableElement::extension_elements(self : CallableElement) -> Field[ExtensionElements]

    CallableElement::from_element

    source
    fn CallableElement::from_element(element : Element) -> CallableElement?

    CallableElement::id

    source
    fn CallableElement::id(self : CallableElement) -> Field[String]

    CallableElement::io_binding

    source
    fn CallableElement::io_binding(self : CallableElement) -> Field[ReadOnlyArray[InputOutputBinding]]

    CallableElement::io_specification

    source

    CallableElement::name

    source
    fn CallableElement::name(self : CallableElement) -> Field[String]

    CallableElement::new

    source
    fn CallableElement::new(id? : String, name? : String, contents? : ArrayView[Content]) -> CallableElement

    CallableElement::not_equal

    source
    fn CallableElement::not_equal(x : CallableElement, y : CallableElement) -> Bool

    CallableElement::supported_interface_ref

    source
    fn CallableElement::supported_interface_ref(self : CallableElement) -> Field[ReadOnlyArray[Reference]]

    CallableElement::to_repr

    source

    CancelEventDefinition

    source
    pub struct CancelEventDefinition {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tCancelEventDefinition.

    CancelEventDefinition::documentation

    source
    fn CancelEventDefinition::documentation(self : CancelEventDefinition) -> Field[ReadOnlyArray[Documentation]]

    CancelEventDefinition::equal

    source

    CancelEventDefinition::extension_elements

    source

    CancelEventDefinition::from_element

    source
    fn CancelEventDefinition::from_element(element : Element) -> CancelEventDefinition?

    CancelEventDefinition::id

    source

    CancelEventDefinition::new

    source
    fn CancelEventDefinition::new(id? : String, contents? : ArrayView[Content]) -> CancelEventDefinition

    CancelEventDefinition::not_equal

    source

    CancelEventDefinition::to_repr

    source

    CatchEvent

    source
    pub struct CatchEvent {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tCatchEvent.

    CatchEvent::auditing

    source
    fn CatchEvent::auditing(self : CatchEvent) -> Field[Auditing]

    CatchEvent::category_value_ref

    source
    fn CatchEvent::category_value_ref(self : CatchEvent) -> Field[ReadOnlyArray[Reference]]

    CatchEvent::data_output

    source
    fn CatchEvent::data_output(self : CatchEvent) -> Field[ReadOnlyArray[DataOutput]]

    CatchEvent::data_output_association

    source
    fn CatchEvent::data_output_association(self : CatchEvent) -> Field[ReadOnlyArray[DataOutputAssociation]]

    CatchEvent::documentation

    source
    fn CatchEvent::documentation(self : CatchEvent) -> Field[ReadOnlyArray[Documentation]]

    CatchEvent::equal

    source
    fn CatchEvent::equal(CatchEvent, CatchEvent) -> Bool

    CatchEvent::event_definition

    source
    fn CatchEvent::event_definition(self : CatchEvent) -> Field[ReadOnlyArray[EventDefinition]]

    CatchEvent::event_definition_ref

    source
    fn CatchEvent::event_definition_ref(self : CatchEvent) -> Field[ReadOnlyArray[Reference]]

    CatchEvent::extension_elements

    source
    fn CatchEvent::extension_elements(self : CatchEvent) -> Field[ExtensionElements]

    CatchEvent::from_element

    source
    fn CatchEvent::from_element(element : Element) -> CatchEvent?

    CatchEvent::id

    source
    fn CatchEvent::id(self : CatchEvent) -> Field[String]

    CatchEvent::incoming

    source
    fn CatchEvent::incoming(self : CatchEvent) -> Field[ReadOnlyArray[Reference]]

    CatchEvent::monitoring

    source
    fn CatchEvent::monitoring(self : CatchEvent) -> Field[Monitoring]

    CatchEvent::name

    source
    fn CatchEvent::name(self : CatchEvent) -> Field[String]

    CatchEvent::not_equal

    source
    fn CatchEvent::not_equal(x : CatchEvent, y : CatchEvent) -> Bool

    CatchEvent::outgoing

    source
    fn CatchEvent::outgoing(self : CatchEvent) -> Field[ReadOnlyArray[Reference]]

    CatchEvent::output_set

    source
    fn CatchEvent::output_set(self : CatchEvent) -> Field[OutputSet]

    CatchEvent::parallel_multiple

    source
    fn CatchEvent::parallel_multiple(self : CatchEvent) -> Field[Bool]

    CatchEvent::property

    source
    fn CatchEvent::property(self : CatchEvent) -> Field[ReadOnlyArray[Property]]

    CatchEvent::to_repr

    source

    Category

    source
    pub struct Category {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tCategory.

    Category::category_value

    source
    fn Category::category_value(self : Category) -> Field[ReadOnlyArray[CategoryValue]]

    Category::documentation

    source
    fn Category::documentation(self : Category) -> Field[ReadOnlyArray[Documentation]]

    Category::equal

    source
    fn Category::equal(Category, Category) -> Bool

    Category::extension_elements

    source
    fn Category::extension_elements(self : Category) -> Field[ExtensionElements]

    Category::from_element

    source
    fn Category::from_element(element : Element) -> Category?

    Category::id

    source
    fn Category::id(self : Category) -> Field[String]

    Category::name

    source
    fn Category::name(self : Category) -> Field[String]

    Category::new

    source
    fn Category::new(id? : String, name? : String, contents? : ArrayView[Content]) -> Category

    Category::not_equal

    source
    fn Category::not_equal(x : Category, y : Category) -> Bool

    Category::to_repr

    source

    CategoryValue

    source
    pub struct CategoryValue {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tCategoryValue.

    CategoryValue::documentation

    source
    fn CategoryValue::documentation(self : CategoryValue) -> Field[ReadOnlyArray[Documentation]]

    CategoryValue::equal

    source

    CategoryValue::extension_elements

    source
    fn CategoryValue::extension_elements(self : CategoryValue) -> Field[ExtensionElements]

    CategoryValue::from_element

    source
    fn CategoryValue::from_element(element : Element) -> CategoryValue?

    CategoryValue::id

    source
    fn CategoryValue::id(self : CategoryValue) -> Field[String]

    CategoryValue::new

    source
    fn CategoryValue::new(id? : String, value? : String, contents? : ArrayView[Content]) -> CategoryValue

    CategoryValue::not_equal

    source
    fn CategoryValue::not_equal(x : CategoryValue, y : CategoryValue) -> Bool

    CategoryValue::to_repr

    source

    CategoryValue::value

    source
    fn CategoryValue::value(self : CategoryValue) -> Field[String]

    Choreography

    source
    pub struct Choreography {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tChoreography.

    Choreography::artifact

    source
    fn Choreography::artifact(self : Choreography) -> Field[ReadOnlyArray[Artifact]]

    Choreography::choreography_ref

    source
    fn Choreography::choreography_ref(self : Choreography) -> Field[ReadOnlyArray[Reference]]

    Choreography::conversation_association

    source
    fn Choreography::conversation_association(self : Choreography) -> Field[ReadOnlyArray[ConversationAssociation]]

    fn Choreography::conversation_link(self : Choreography) -> Field[ReadOnlyArray[ConversationLink]]

    Choreography::conversation_node

    source
    fn Choreography::conversation_node(self : Choreography) -> Field[ReadOnlyArray[ConversationNode]]

    Choreography::correlation_key

    source
    fn Choreography::correlation_key(self : Choreography) -> Field[ReadOnlyArray[CorrelationKey]]

    Choreography::documentation

    source
    fn Choreography::documentation(self : Choreography) -> Field[ReadOnlyArray[Documentation]]

    Choreography::equal

    source

    Choreography::extension_elements

    source
    fn Choreography::extension_elements(self : Choreography) -> Field[ExtensionElements]

    Choreography::flow_element

    source
    fn Choreography::flow_element(self : Choreography) -> Field[ReadOnlyArray[FlowElement]]

    Choreography::from_element

    source
    fn Choreography::from_element(element : Element) -> Choreography?

    Choreography::id

    source
    fn Choreography::id(self : Choreography) -> Field[String]

    Choreography::is_closed

    source
    fn Choreography::is_closed(self : Choreography) -> Field[Bool]

    Choreography::message_flow

    source
    fn Choreography::message_flow(self : Choreography) -> Field[ReadOnlyArray[MessageFlow]]

    Choreography::message_flow_association

    source
    fn Choreography::message_flow_association(self : Choreography) -> Field[ReadOnlyArray[MessageFlowAssociation]]

    Choreography::name

    source
    fn Choreography::name(self : Choreography) -> Field[String]

    Choreography::new

    source
    fn Choreography::new(id? : String, name? : String, is_closed? : Bool, contents? : ArrayView[Content]) -> Choreography

    Choreography::not_equal

    source
    fn Choreography::not_equal(x : Choreography, y : Choreography) -> Bool

    Choreography::participant

    source
    fn Choreography::participant(self : Choreography) -> Field[ReadOnlyArray[Participant]]

    Choreography::participant_association

    source
    fn Choreography::participant_association(self : Choreography) -> Field[ReadOnlyArray[ParticipantAssociation]]

    Choreography::to_repr

    source

    ChoreographyActivity

    source
    pub struct ChoreographyActivity {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tChoreographyActivity.

    ChoreographyActivity::auditing

    source

    ChoreographyActivity::category_value_ref

    source
    fn ChoreographyActivity::category_value_ref(self : ChoreographyActivity) -> Field[ReadOnlyArray[Reference]]

    ChoreographyActivity::correlation_key

    source
    fn ChoreographyActivity::correlation_key(self : ChoreographyActivity) -> Field[ReadOnlyArray[CorrelationKey]]

    ChoreographyActivity::documentation

    source
    fn ChoreographyActivity::documentation(self : ChoreographyActivity) -> Field[ReadOnlyArray[Documentation]]

    ChoreographyActivity::equal

    source

    ChoreographyActivity::extension_elements

    source

    ChoreographyActivity::from_element

    source
    fn ChoreographyActivity::from_element(element : Element) -> ChoreographyActivity?

    ChoreographyActivity::id

    source

    ChoreographyActivity::incoming

    source
    fn ChoreographyActivity::incoming(self : ChoreographyActivity) -> Field[ReadOnlyArray[Reference]]

    ChoreographyActivity::initiating_participant_ref

    source
    fn ChoreographyActivity::initiating_participant_ref(self : ChoreographyActivity) -> Field[Reference]

    ChoreographyActivity::loop_type

    source

    ChoreographyActivity::monitoring

    source

    ChoreographyActivity::name

    source
    fn ChoreographyActivity::name(self : ChoreographyActivity) -> Field[String]

    ChoreographyActivity::not_equal

    source

    ChoreographyActivity::outgoing

    source
    fn ChoreographyActivity::outgoing(self : ChoreographyActivity) -> Field[ReadOnlyArray[Reference]]

    ChoreographyActivity::participant_ref

    source
    fn ChoreographyActivity::participant_ref(self : ChoreographyActivity) -> Field[ReadOnlyArray[Reference]]

    ChoreographyActivity::to_repr

    source

    ChoreographyLoopType

    source
    pub(all) enum ChoreographyLoopType {
      None
      Standard
      MultiInstanceSequential
      MultiInstanceParallel
    } derive(Eq, 
    Debug    )

    Values of the pinned XSD type tChoreographyLoopType.

    ChoreographyLoopType::equal

    source

    ChoreographyLoopType::not_equal

    source

    ChoreographyLoopType::parse

    source
    fn ChoreographyLoopType::parse(token : String) -> ChoreographyLoopType?

    ChoreographyLoopType::to_repr

    source

    ChoreographyLoopType::token

    source
    fn ChoreographyLoopType::token(self : ChoreographyLoopType) -> String

    ChoreographyTask

    source
    pub struct ChoreographyTask {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tChoreographyTask.

    ChoreographyTask::auditing

    source

    ChoreographyTask::category_value_ref

    source
    fn ChoreographyTask::category_value_ref(self : ChoreographyTask) -> Field[ReadOnlyArray[Reference]]

    ChoreographyTask::correlation_key

    source
    fn ChoreographyTask::correlation_key(self : ChoreographyTask) -> Field[ReadOnlyArray[CorrelationKey]]

    ChoreographyTask::documentation

    source
    fn ChoreographyTask::documentation(self : ChoreographyTask) -> Field[ReadOnlyArray[Documentation]]

    ChoreographyTask::equal

    source

    ChoreographyTask::extension_elements

    source
    fn ChoreographyTask::extension_elements(self : ChoreographyTask) -> Field[ExtensionElements]

    ChoreographyTask::from_element

    source
    fn ChoreographyTask::from_element(element : Element) -> ChoreographyTask?

    ChoreographyTask::id

    source
    fn ChoreographyTask::id(self : ChoreographyTask) -> Field[String]

    ChoreographyTask::incoming

    source
    fn ChoreographyTask::incoming(self : ChoreographyTask) -> Field[ReadOnlyArray[Reference]]

    ChoreographyTask::initiating_participant_ref

    source
    fn ChoreographyTask::initiating_participant_ref(self : ChoreographyTask) -> Field[Reference]

    ChoreographyTask::loop_type

    source

    ChoreographyTask::message_flow_ref

    source
    fn ChoreographyTask::message_flow_ref(self : ChoreographyTask) -> Field[ReadOnlyArray[Reference]]

    ChoreographyTask::monitoring

    source

    ChoreographyTask::name

    source
    fn ChoreographyTask::name(self : ChoreographyTask) -> Field[String]

    ChoreographyTask::new

    source
    fn ChoreographyTask::new(id? : String, name? : String, initiating_participant_ref? : Reference, loop_type? : ChoreographyLoopType, contents? : ArrayView[Content]) -> ChoreographyTask

    ChoreographyTask::not_equal

    source
    fn ChoreographyTask::not_equal(x : ChoreographyTask, y : ChoreographyTask) -> Bool

    ChoreographyTask::outgoing

    source
    fn ChoreographyTask::outgoing(self : ChoreographyTask) -> Field[ReadOnlyArray[Reference]]

    ChoreographyTask::participant_ref

    source
    fn ChoreographyTask::participant_ref(self : ChoreographyTask) -> Field[ReadOnlyArray[Reference]]

    ChoreographyTask::to_repr

    source

    Collaboration

    source
    pub struct Collaboration {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tCollaboration.

    Collaboration::artifact

    source
    fn Collaboration::artifact(self : Collaboration) -> Field[ReadOnlyArray[Artifact]]

    Collaboration::choreography_ref

    source
    fn Collaboration::choreography_ref(self : Collaboration) -> Field[ReadOnlyArray[Reference]]

    Collaboration::conversation_association

    source
    fn Collaboration::conversation_association(self : Collaboration) -> Field[ReadOnlyArray[ConversationAssociation]]

    fn Collaboration::conversation_link(self : Collaboration) -> Field[ReadOnlyArray[ConversationLink]]

    Collaboration::conversation_node

    source
    fn Collaboration::conversation_node(self : Collaboration) -> Field[ReadOnlyArray[ConversationNode]]

    Collaboration::correlation_key

    source
    fn Collaboration::correlation_key(self : Collaboration) -> Field[ReadOnlyArray[CorrelationKey]]

    Collaboration::documentation

    source
    fn Collaboration::documentation(self : Collaboration) -> Field[ReadOnlyArray[Documentation]]

    Collaboration::equal

    source

    Collaboration::extension_elements

    source
    fn Collaboration::extension_elements(self : Collaboration) -> Field[ExtensionElements]

    Collaboration::from_element

    source
    fn Collaboration::from_element(element : Element) -> Collaboration?

    Collaboration::id

    source
    fn Collaboration::id(self : Collaboration) -> Field[String]

    Collaboration::is_closed

    source
    fn Collaboration::is_closed(self : Collaboration) -> Field[Bool]

    Collaboration::message_flow

    source
    fn Collaboration::message_flow(self : Collaboration) -> Field[ReadOnlyArray[MessageFlow]]

    Collaboration::message_flow_association

    source
    fn Collaboration::message_flow_association(self : Collaboration) -> Field[ReadOnlyArray[MessageFlowAssociation]]

    Collaboration::name

    source
    fn Collaboration::name(self : Collaboration) -> Field[String]

    Collaboration::new

    source
    fn Collaboration::new(id? : String, name? : String, is_closed? : Bool, contents? : ArrayView[Content]) -> Collaboration

    Collaboration::not_equal

    source
    fn Collaboration::not_equal(x : Collaboration, y : Collaboration) -> Bool

    Collaboration::participant

    source
    fn Collaboration::participant(self : Collaboration) -> Field[ReadOnlyArray[Participant]]

    Collaboration::participant_association

    source
    fn Collaboration::participant_association(self : Collaboration) -> Field[ReadOnlyArray[ParticipantAssociation]]

    Collaboration::to_repr

    source

    CompensateEventDefinition

    source
    pub struct CompensateEventDefinition {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tCompensateEventDefinition.

    CompensateEventDefinition::activity_ref

    source

    CompensateEventDefinition::documentation

    source
    fn CompensateEventDefinition::documentation(self : CompensateEventDefinition) -> Field[ReadOnlyArray[Documentation]]

    CompensateEventDefinition::equal

    source

    CompensateEventDefinition::extension_elements

    source

    CompensateEventDefinition::from_element

    source

    CompensateEventDefinition::id

    source

    CompensateEventDefinition::new

    source
    fn CompensateEventDefinition::new(id? : String, wait_for_completion? : Bool, activity_ref? : Reference, contents? : ArrayView[Content]) -> CompensateEventDefinition

    CompensateEventDefinition::not_equal

    source

    CompensateEventDefinition::to_repr

    source

    CompensateEventDefinition::wait_for_completion

    source
    fn CompensateEventDefinition::wait_for_completion(self : CompensateEventDefinition) -> Field[Bool]

    ComplexBehaviorDefinition

    source
    pub struct ComplexBehaviorDefinition {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tComplexBehaviorDefinition.

    ComplexBehaviorDefinition::condition

    source

    ComplexBehaviorDefinition::documentation

    source
    fn ComplexBehaviorDefinition::documentation(self : ComplexBehaviorDefinition) -> Field[ReadOnlyArray[Documentation]]

    ComplexBehaviorDefinition::equal

    source

    ComplexBehaviorDefinition::event

    source

    ComplexBehaviorDefinition::extension_elements

    source

    ComplexBehaviorDefinition::from_element

    source

    ComplexBehaviorDefinition::id

    source

    ComplexBehaviorDefinition::new

    source

    ComplexBehaviorDefinition::not_equal

    source

    ComplexBehaviorDefinition::to_repr

    source

    ComplexGateway

    source
    pub struct ComplexGateway {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tComplexGateway.

    ComplexGateway::activation_condition

    source
    fn ComplexGateway::activation_condition(self : ComplexGateway) -> Field[Expression]

    ComplexGateway::auditing

    source
    fn ComplexGateway::auditing(self : ComplexGateway) -> Field[Auditing]

    ComplexGateway::category_value_ref

    source
    fn ComplexGateway::category_value_ref(self : ComplexGateway) -> Field[ReadOnlyArray[Reference]]

    ComplexGateway::default_

    source
    fn ComplexGateway::default_(self : ComplexGateway) -> Field[Reference]

    ComplexGateway::documentation

    source
    fn ComplexGateway::documentation(self : ComplexGateway) -> Field[ReadOnlyArray[Documentation]]

    ComplexGateway::equal

    source

    ComplexGateway::extension_elements

    source
    fn ComplexGateway::extension_elements(self : ComplexGateway) -> Field[ExtensionElements]

    ComplexGateway::from_element

    source
    fn ComplexGateway::from_element(element : Element) -> ComplexGateway?

    ComplexGateway::gateway_direction

    source
    fn ComplexGateway::gateway_direction(self : ComplexGateway) -> Field[GatewayDirection]

    ComplexGateway::id

    source
    fn ComplexGateway::id(self : ComplexGateway) -> Field[String]

    ComplexGateway::incoming

    source
    fn ComplexGateway::incoming(self : ComplexGateway) -> Field[ReadOnlyArray[Reference]]

    ComplexGateway::monitoring

    source
    fn ComplexGateway::monitoring(self : ComplexGateway) -> Field[Monitoring]

    ComplexGateway::name

    source
    fn ComplexGateway::name(self : ComplexGateway) -> Field[String]

    ComplexGateway::new

    source
    fn ComplexGateway::new(id? : String, name? : String, gateway_direction? : GatewayDirection, default_? : Reference, contents? : ArrayView[Content]) -> ComplexGateway

    ComplexGateway::not_equal

    source
    fn ComplexGateway::not_equal(x : ComplexGateway, y : ComplexGateway) -> Bool

    ComplexGateway::outgoing

    source
    fn ComplexGateway::outgoing(self : ComplexGateway) -> Field[ReadOnlyArray[Reference]]

    ComplexGateway::to_repr

    source

    ConditionalEventDefinition

    source
    pub struct ConditionalEventDefinition {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tConditionalEventDefinition.

    ConditionalEventDefinition::condition

    source

    ConditionalEventDefinition::documentation

    source
    fn ConditionalEventDefinition::documentation(self : ConditionalEventDefinition) -> Field[ReadOnlyArray[Documentation]]

    ConditionalEventDefinition::equal

    source

    ConditionalEventDefinition::extension_elements

    source

    ConditionalEventDefinition::from_element

    source

    ConditionalEventDefinition::id

    source

    ConditionalEventDefinition::new

    source

    ConditionalEventDefinition::not_equal

    source

    ConditionalEventDefinition::to_repr

    source

    Content

    source
    pub(all) enum Content {
      Text(String)
      Element(Element)
      Comment(String)
      ProcessingInstruction(target~ : String, data~ : String)
    } derive(Eq, 
    Debug    )

    Ordered semantic content. Text and element order are independent of source token spelling. Comments and processing instructions are inert document data.

    Content::equal

    source
    fn Content::equal(Content, Content) -> Bool

    Content::not_equal

    source
    fn Content::not_equal(x : Content, y : Content) -> Bool

    Content::to_repr

    source

    Control

    source
    pub(all) enum Control {
      Continue
      SkipChildren
      Stop
    } derive(Eq, 
    Debug    )

    Control::equal

    source
    fn Control::equal(Control, Control) -> Bool

    Control::not_equal

    source
    fn Control::not_equal(x : Control, y : Control) -> Bool

    Control::to_repr

    source

    Conversation

    source
    pub struct Conversation {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tConversation.

    Conversation::correlation_key

    source
    fn Conversation::correlation_key(self : Conversation) -> Field[ReadOnlyArray[CorrelationKey]]

    Conversation::documentation

    source
    fn Conversation::documentation(self : Conversation) -> Field[ReadOnlyArray[Documentation]]

    Conversation::equal

    source

    Conversation::extension_elements

    source
    fn Conversation::extension_elements(self : Conversation) -> Field[ExtensionElements]

    Conversation::from_element

    source
    fn Conversation::from_element(element : Element) -> Conversation?

    Conversation::id

    source
    fn Conversation::id(self : Conversation) -> Field[String]

    Conversation::message_flow_ref

    source
    fn Conversation::message_flow_ref(self : Conversation) -> Field[ReadOnlyArray[Reference]]

    Conversation::name

    source
    fn Conversation::name(self : Conversation) -> Field[String]

    Conversation::new

    source
    fn Conversation::new(id? : String, name? : String, contents? : ArrayView[Content]) -> Conversation

    Conversation::not_equal

    source
    fn Conversation::not_equal(x : Conversation, y : Conversation) -> Bool

    Conversation::participant_ref

    source
    fn Conversation::participant_ref(self : Conversation) -> Field[ReadOnlyArray[Reference]]

    Conversation::to_repr

    source

    ConversationAssociation

    source
    pub struct ConversationAssociation {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tConversationAssociation.

    ConversationAssociation::documentation

    source
    fn ConversationAssociation::documentation(self : ConversationAssociation) -> Field[ReadOnlyArray[Documentation]]

    ConversationAssociation::equal

    source

    ConversationAssociation::extension_elements

    source

    ConversationAssociation::from_element

    source

    ConversationAssociation::id

    source

    ConversationAssociation::inner_conversation_node_ref

    source
    fn ConversationAssociation::inner_conversation_node_ref(self : ConversationAssociation) -> Field[Reference]

    ConversationAssociation::new

    source
    fn ConversationAssociation::new(id? : String, inner_conversation_node_ref? : Reference, outer_conversation_node_ref? : Reference, contents? : ArrayView[Content]) -> ConversationAssociation

    ConversationAssociation::not_equal

    source

    ConversationAssociation::outer_conversation_node_ref

    source
    fn ConversationAssociation::outer_conversation_node_ref(self : ConversationAssociation) -> Field[Reference]

    ConversationAssociation::to_repr

    source

    pub struct ConversationLink {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tConversationLink.

    ConversationLink::documentation

    source
    fn ConversationLink::documentation(self : ConversationLink) -> Field[ReadOnlyArray[Documentation]]

    ConversationLink::equal

    source

    ConversationLink::extension_elements

    source
    fn ConversationLink::extension_elements(self : ConversationLink) -> Field[ExtensionElements]

    ConversationLink::from_element

    source
    fn ConversationLink::from_element(element : Element) -> ConversationLink?

    ConversationLink::id

    source
    fn ConversationLink::id(self : ConversationLink) -> Field[String]

    ConversationLink::name

    source
    fn ConversationLink::name(self : ConversationLink) -> Field[String]

    ConversationLink::new

    source
    fn ConversationLink::new(id? : String, name? : String, source_ref? : Reference, target_ref? : Reference, contents? : ArrayView[Content]) -> ConversationLink

    ConversationLink::not_equal

    source
    fn ConversationLink::not_equal(x : ConversationLink, y : ConversationLink) -> Bool

    ConversationLink::source_ref

    source

    ConversationLink::target_ref

    source

    ConversationLink::to_repr

    source

    ConversationNode

    source
    pub struct ConversationNode {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tConversationNode.

    ConversationNode::correlation_key

    source
    fn ConversationNode::correlation_key(self : ConversationNode) -> Field[ReadOnlyArray[CorrelationKey]]

    ConversationNode::documentation

    source
    fn ConversationNode::documentation(self : ConversationNode) -> Field[ReadOnlyArray[Documentation]]

    ConversationNode::equal

    source

    ConversationNode::extension_elements

    source
    fn ConversationNode::extension_elements(self : ConversationNode) -> Field[ExtensionElements]

    ConversationNode::from_element

    source
    fn ConversationNode::from_element(element : Element) -> ConversationNode?

    ConversationNode::id

    source
    fn ConversationNode::id(self : ConversationNode) -> Field[String]

    ConversationNode::message_flow_ref

    source
    fn ConversationNode::message_flow_ref(self : ConversationNode) -> Field[ReadOnlyArray[Reference]]

    ConversationNode::name

    source
    fn ConversationNode::name(self : ConversationNode) -> Field[String]

    ConversationNode::not_equal

    source
    fn ConversationNode::not_equal(x : ConversationNode, y : ConversationNode) -> Bool

    ConversationNode::participant_ref

    source
    fn ConversationNode::participant_ref(self : ConversationNode) -> Field[ReadOnlyArray[Reference]]

    ConversationNode::to_repr

    source

    CorrelationKey

    source
    pub struct CorrelationKey {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tCorrelationKey.

    CorrelationKey::correlation_property_ref

    source
    fn CorrelationKey::correlation_property_ref(self : CorrelationKey) -> Field[ReadOnlyArray[Reference]]

    CorrelationKey::documentation

    source
    fn CorrelationKey::documentation(self : CorrelationKey) -> Field[ReadOnlyArray[Documentation]]

    CorrelationKey::equal

    source

    CorrelationKey::extension_elements

    source
    fn CorrelationKey::extension_elements(self : CorrelationKey) -> Field[ExtensionElements]

    CorrelationKey::from_element

    source
    fn CorrelationKey::from_element(element : Element) -> CorrelationKey?

    CorrelationKey::id

    source
    fn CorrelationKey::id(self : CorrelationKey) -> Field[String]

    CorrelationKey::name

    source
    fn CorrelationKey::name(self : CorrelationKey) -> Field[String]

    CorrelationKey::new

    source
    fn CorrelationKey::new(id? : String, name? : String, contents? : ArrayView[Content]) -> CorrelationKey

    CorrelationKey::not_equal

    source
    fn CorrelationKey::not_equal(x : CorrelationKey, y : CorrelationKey) -> Bool

    CorrelationKey::to_repr

    source

    CorrelationProperty

    source
    pub struct CorrelationProperty {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tCorrelationProperty.

    CorrelationProperty::correlation_property_retrieval_expression

    source
    fn CorrelationProperty::correlation_property_retrieval_expression(self : CorrelationProperty) -> Field[ReadOnlyArray[CorrelationPropertyRetrievalExpression]]

    CorrelationProperty::documentation

    source
    fn CorrelationProperty::documentation(self : CorrelationProperty) -> Field[ReadOnlyArray[Documentation]]

    CorrelationProperty::equal

    source

    CorrelationProperty::extension_elements

    source

    CorrelationProperty::from_element

    source
    fn CorrelationProperty::from_element(element : Element) -> CorrelationProperty?

    CorrelationProperty::id

    source

    CorrelationProperty::name

    source
    fn CorrelationProperty::name(self : CorrelationProperty) -> Field[String]

    CorrelationProperty::new

    source
    fn CorrelationProperty::new(id? : String, name? : String, type_? : Reference, contents? : ArrayView[Content]) -> CorrelationProperty

    CorrelationProperty::not_equal

    source

    CorrelationProperty::to_repr

    source

    CorrelationProperty::type_

    source

    CorrelationPropertyBinding

    source
    pub struct CorrelationPropertyBinding {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tCorrelationPropertyBinding.

    CorrelationPropertyBinding::correlation_property_ref

    source
    fn CorrelationPropertyBinding::correlation_property_ref(self : CorrelationPropertyBinding) -> Field[Reference]

    CorrelationPropertyBinding::data_path

    source

    CorrelationPropertyBinding::documentation

    source
    fn CorrelationPropertyBinding::documentation(self : CorrelationPropertyBinding) -> Field[ReadOnlyArray[Documentation]]

    CorrelationPropertyBinding::equal

    source

    CorrelationPropertyBinding::extension_elements

    source

    CorrelationPropertyBinding::from_element

    source

    CorrelationPropertyBinding::id

    source

    CorrelationPropertyBinding::new

    source
    fn CorrelationPropertyBinding::new(id? : String, correlation_property_ref? : Reference, contents? : ArrayView[Content]) -> CorrelationPropertyBinding

    CorrelationPropertyBinding::not_equal

    source

    CorrelationPropertyBinding::to_repr

    source

    CorrelationPropertyRetrievalExpression

    source
    pub struct CorrelationPropertyRetrievalExpression {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tCorrelationPropertyRetrievalExpression.

    CorrelationPropertyRetrievalExpression::documentation

    source

    CorrelationPropertyRetrievalExpression::equal

    source

    CorrelationPropertyRetrievalExpression::extension_elements

    source

    CorrelationPropertyRetrievalExpression::from_element

    source

    CorrelationPropertyRetrievalExpression::id

    source

    CorrelationPropertyRetrievalExpression::message_path

    source

    CorrelationPropertyRetrievalExpression::message_ref

    source

    CorrelationPropertyRetrievalExpression::new

    source

    CorrelationPropertyRetrievalExpression::not_equal

    source

    CorrelationPropertyRetrievalExpression::to_repr

    source

    CorrelationSubscription

    source
    pub struct CorrelationSubscription {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tCorrelationSubscription.

    CorrelationSubscription::correlation_key_ref

    source

    CorrelationSubscription::correlation_property_binding

    source
    fn CorrelationSubscription::correlation_property_binding(self : CorrelationSubscription) -> Field[ReadOnlyArray[CorrelationPropertyBinding]]

    CorrelationSubscription::documentation

    source
    fn CorrelationSubscription::documentation(self : CorrelationSubscription) -> Field[ReadOnlyArray[Documentation]]

    CorrelationSubscription::equal

    source

    CorrelationSubscription::extension_elements

    source

    CorrelationSubscription::from_element

    source

    CorrelationSubscription::id

    source

    CorrelationSubscription::new

    source
    fn CorrelationSubscription::new(id? : String, correlation_key_ref? : Reference, contents? : ArrayView[Content]) -> CorrelationSubscription

    CorrelationSubscription::not_equal

    source

    CorrelationSubscription::to_repr

    source

    Cst

    source
    pub struct Cst {
      tokens : ReadOnlyArray[Token]
      nodes : ReadOnlyArray[XmlNode]
      complete : Bool
    } derive(Eq, 
    Debug    )

    Cst::equal

    source
    fn Cst::equal(Cst, Cst) -> Bool

    Cst::not_equal

    source
    fn Cst::not_equal(x : Cst, y : Cst) -> Bool

    Cst::text

    source
    fn Cst::text(self : Cst) -> String

    Cst::to_repr

    source

    DataAssociation

    source
    pub struct DataAssociation {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tDataAssociation.

    DataAssociation::assignment

    source
    fn DataAssociation::assignment(self : DataAssociation) -> Field[ReadOnlyArray[Assignment]]

    DataAssociation::documentation

    source
    fn DataAssociation::documentation(self : DataAssociation) -> Field[ReadOnlyArray[Documentation]]

    DataAssociation::equal

    source

    DataAssociation::extension_elements

    source
    fn DataAssociation::extension_elements(self : DataAssociation) -> Field[ExtensionElements]

    DataAssociation::from_element

    source
    fn DataAssociation::from_element(element : Element) -> DataAssociation?

    DataAssociation::id

    source
    fn DataAssociation::id(self : DataAssociation) -> Field[String]

    DataAssociation::new

    source
    fn DataAssociation::new(id? : String, contents? : ArrayView[Content]) -> DataAssociation

    DataAssociation::not_equal

    source
    fn DataAssociation::not_equal(x : DataAssociation, y : DataAssociation) -> Bool

    DataAssociation::source_ref

    source
    fn DataAssociation::source_ref(self : DataAssociation) -> Field[ReadOnlyArray[Reference]]

    DataAssociation::target_ref

    source
    fn DataAssociation::target_ref(self : DataAssociation) -> Field[Reference]

    DataAssociation::to_repr

    source

    DataAssociation::transformation

    source
    fn DataAssociation::transformation(self : DataAssociation) -> Field[FormalExpression]

    DataInput

    source
    pub struct DataInput {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tDataInput.

    DataInput::data_state

    source
    fn DataInput::data_state(self : DataInput) -> Field[DataState]

    DataInput::documentation

    source
    fn DataInput::documentation(self : DataInput) -> Field[ReadOnlyArray[Documentation]]

    DataInput::equal

    source
    fn DataInput::equal(DataInput, DataInput) -> Bool

    DataInput::extension_elements

    source
    fn DataInput::extension_elements(self : DataInput) -> Field[ExtensionElements]

    DataInput::from_element

    source
    fn DataInput::from_element(element : Element) -> DataInput?

    DataInput::id

    source
    fn DataInput::id(self : DataInput) -> Field[String]

    DataInput::is_collection

    source
    fn DataInput::is_collection(self : DataInput) -> Field[Bool]

    DataInput::item_subject_ref

    source
    fn DataInput::item_subject_ref(self : DataInput) -> Field[Reference]

    DataInput::name

    source
    fn DataInput::name(self : DataInput) -> Field[String]

    DataInput::new

    source
    fn DataInput::new(id? : String, name? : String, item_subject_ref? : Reference, is_collection? : Bool, contents? : ArrayView[Content]) -> DataInput

    DataInput::not_equal

    source
    fn DataInput::not_equal(x : DataInput, y : DataInput) -> Bool

    DataInput::to_repr

    source

    DataInputAssociation

    source
    pub struct DataInputAssociation {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tDataInputAssociation.

    DataInputAssociation::assignment

    source
    fn DataInputAssociation::assignment(self : DataInputAssociation) -> Field[ReadOnlyArray[Assignment]]

    DataInputAssociation::documentation

    source
    fn DataInputAssociation::documentation(self : DataInputAssociation) -> Field[ReadOnlyArray[Documentation]]

    DataInputAssociation::equal

    source

    DataInputAssociation::extension_elements

    source

    DataInputAssociation::from_element

    source
    fn DataInputAssociation::from_element(element : Element) -> DataInputAssociation?

    DataInputAssociation::id

    source

    DataInputAssociation::new

    source
    fn DataInputAssociation::new(id? : String, contents? : ArrayView[Content]) -> DataInputAssociation

    DataInputAssociation::not_equal

    source

    DataInputAssociation::source_ref

    source
    fn DataInputAssociation::source_ref(self : DataInputAssociation) -> Field[ReadOnlyArray[Reference]]

    DataInputAssociation::target_ref

    source

    DataInputAssociation::to_repr

    source

    DataInputAssociation::transformation

    source

    DataObject

    source
    pub struct DataObject {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tDataObject.

    DataObject::auditing

    source
    fn DataObject::auditing(self : DataObject) -> Field[Auditing]

    DataObject::category_value_ref

    source
    fn DataObject::category_value_ref(self : DataObject) -> Field[ReadOnlyArray[Reference]]

    DataObject::data_state

    source
    fn DataObject::data_state(self : DataObject) -> Field[DataState]

    DataObject::documentation

    source
    fn DataObject::documentation(self : DataObject) -> Field[ReadOnlyArray[Documentation]]

    DataObject::equal

    source
    fn DataObject::equal(DataObject, DataObject) -> Bool

    DataObject::extension_elements

    source
    fn DataObject::extension_elements(self : DataObject) -> Field[ExtensionElements]

    DataObject::from_element

    source
    fn DataObject::from_element(element : Element) -> DataObject?

    DataObject::id

    source
    fn DataObject::id(self : DataObject) -> Field[String]

    DataObject::is_collection

    source
    fn DataObject::is_collection(self : DataObject) -> Field[Bool]

    DataObject::item_subject_ref

    source
    fn DataObject::item_subject_ref(self : DataObject) -> Field[Reference]

    DataObject::monitoring

    source
    fn DataObject::monitoring(self : DataObject) -> Field[Monitoring]

    DataObject::name

    source
    fn DataObject::name(self : DataObject) -> Field[String]

    DataObject::new

    source
    fn DataObject::new(id? : String, name? : String, item_subject_ref? : Reference, is_collection? : Bool, contents? : ArrayView[Content]) -> DataObject

    DataObject::not_equal

    source
    fn DataObject::not_equal(x : DataObject, y : DataObject) -> Bool

    DataObject::to_repr

    source

    DataObjectReference

    source
    pub struct DataObjectReference {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tDataObjectReference.

    DataObjectReference::auditing

    source

    DataObjectReference::category_value_ref

    source
    fn DataObjectReference::category_value_ref(self : DataObjectReference) -> Field[ReadOnlyArray[Reference]]

    DataObjectReference::data_object_ref

    source
    fn DataObjectReference::data_object_ref(self : DataObjectReference) -> Field[Reference]

    DataObjectReference::data_state

    source

    DataObjectReference::documentation

    source
    fn DataObjectReference::documentation(self : DataObjectReference) -> Field[ReadOnlyArray[Documentation]]

    DataObjectReference::equal

    source

    DataObjectReference::extension_elements

    source

    DataObjectReference::from_element

    source
    fn DataObjectReference::from_element(element : Element) -> DataObjectReference?

    DataObjectReference::id

    source

    DataObjectReference::item_subject_ref

    source
    fn DataObjectReference::item_subject_ref(self : DataObjectReference) -> Field[Reference]

    DataObjectReference::monitoring

    source

    DataObjectReference::name

    source
    fn DataObjectReference::name(self : DataObjectReference) -> Field[String]

    DataObjectReference::new

    source
    fn DataObjectReference::new(id? : String, name? : String, item_subject_ref? : Reference, data_object_ref? : Reference, contents? : ArrayView[Content]) -> DataObjectReference

    DataObjectReference::not_equal

    source

    DataObjectReference::to_repr

    source

    DataOutput

    source
    pub struct DataOutput {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tDataOutput.

    DataOutput::data_state

    source
    fn DataOutput::data_state(self : DataOutput) -> Field[DataState]

    DataOutput::documentation

    source
    fn DataOutput::documentation(self : DataOutput) -> Field[ReadOnlyArray[Documentation]]

    DataOutput::equal

    source
    fn DataOutput::equal(DataOutput, DataOutput) -> Bool

    DataOutput::extension_elements

    source
    fn DataOutput::extension_elements(self : DataOutput) -> Field[ExtensionElements]

    DataOutput::from_element

    source
    fn DataOutput::from_element(element : Element) -> DataOutput?

    DataOutput::id

    source
    fn DataOutput::id(self : DataOutput) -> Field[String]

    DataOutput::is_collection

    source
    fn DataOutput::is_collection(self : DataOutput) -> Field[Bool]

    DataOutput::item_subject_ref

    source
    fn DataOutput::item_subject_ref(self : DataOutput) -> Field[Reference]

    DataOutput::name

    source
    fn DataOutput::name(self : DataOutput) -> Field[String]

    DataOutput::new

    source
    fn DataOutput::new(id? : String, name? : String, item_subject_ref? : Reference, is_collection? : Bool, contents? : ArrayView[Content]) -> DataOutput

    DataOutput::not_equal

    source
    fn DataOutput::not_equal(x : DataOutput, y : DataOutput) -> Bool

    DataOutput::to_repr

    source

    DataOutputAssociation

    source
    pub struct DataOutputAssociation {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tDataOutputAssociation.

    DataOutputAssociation::assignment

    source
    fn DataOutputAssociation::assignment(self : DataOutputAssociation) -> Field[ReadOnlyArray[Assignment]]

    DataOutputAssociation::documentation

    source
    fn DataOutputAssociation::documentation(self : DataOutputAssociation) -> Field[ReadOnlyArray[Documentation]]

    DataOutputAssociation::equal

    source

    DataOutputAssociation::extension_elements

    source

    DataOutputAssociation::from_element

    source
    fn DataOutputAssociation::from_element(element : Element) -> DataOutputAssociation?

    DataOutputAssociation::id

    source

    DataOutputAssociation::new

    source
    fn DataOutputAssociation::new(id? : String, contents? : ArrayView[Content]) -> DataOutputAssociation

    DataOutputAssociation::not_equal

    source

    DataOutputAssociation::source_ref

    source
    fn DataOutputAssociation::source_ref(self : DataOutputAssociation) -> Field[ReadOnlyArray[Reference]]

    DataOutputAssociation::target_ref

    source

    DataOutputAssociation::to_repr

    source

    DataOutputAssociation::transformation

    source

    DataState

    source
    pub struct DataState {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tDataState.

    DataState::documentation

    source
    fn DataState::documentation(self : DataState) -> Field[ReadOnlyArray[Documentation]]

    DataState::equal

    source
    fn DataState::equal(DataState, DataState) -> Bool

    DataState::extension_elements

    source
    fn DataState::extension_elements(self : DataState) -> Field[ExtensionElements]

    DataState::from_element

    source
    fn DataState::from_element(element : Element) -> DataState?

    DataState::id

    source
    fn DataState::id(self : DataState) -> Field[String]

    DataState::name

    source
    fn DataState::name(self : DataState) -> Field[String]

    DataState::new

    source
    fn DataState::new(id? : String, name? : String, contents? : ArrayView[Content]) -> DataState

    DataState::not_equal

    source
    fn DataState::not_equal(x : DataState, y : DataState) -> Bool

    DataState::to_repr

    source

    DataStore

    source
    pub struct DataStore {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tDataStore.

    DataStore::capacity

    source
    fn DataStore::capacity(self : DataStore) -> Field[ExactInteger]

    DataStore::data_state

    source
    fn DataStore::data_state(self : DataStore) -> Field[DataState]

    DataStore::documentation

    source
    fn DataStore::documentation(self : DataStore) -> Field[ReadOnlyArray[Documentation]]

    DataStore::equal

    source
    fn DataStore::equal(DataStore, DataStore) -> Bool

    DataStore::extension_elements

    source
    fn DataStore::extension_elements(self : DataStore) -> Field[ExtensionElements]

    DataStore::from_element

    source
    fn DataStore::from_element(element : Element) -> DataStore?

    DataStore::id

    source
    fn DataStore::id(self : DataStore) -> Field[String]

    DataStore::is_unlimited

    source
    fn DataStore::is_unlimited(self : DataStore) -> Field[Bool]

    DataStore::item_subject_ref

    source
    fn DataStore::item_subject_ref(self : DataStore) -> Field[Reference]

    DataStore::name

    source
    fn DataStore::name(self : DataStore) -> Field[String]

    DataStore::new

    source
    fn DataStore::new(id? : String, name? : String, capacity? : ExactInteger, is_unlimited? : Bool, item_subject_ref? : Reference, contents? : ArrayView[Content]) -> DataStore

    DataStore::not_equal

    source
    fn DataStore::not_equal(x : DataStore, y : DataStore) -> Bool

    DataStore::to_repr

    source

    DataStoreReference

    source
    pub struct DataStoreReference {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tDataStoreReference.

    DataStoreReference::auditing

    source

    DataStoreReference::category_value_ref

    source
    fn DataStoreReference::category_value_ref(self : DataStoreReference) -> Field[ReadOnlyArray[Reference]]

    DataStoreReference::data_state

    source

    DataStoreReference::data_store_ref

    source
    fn DataStoreReference::data_store_ref(self : DataStoreReference) -> Field[Reference]

    DataStoreReference::documentation

    source
    fn DataStoreReference::documentation(self : DataStoreReference) -> Field[ReadOnlyArray[Documentation]]

    DataStoreReference::equal

    source

    DataStoreReference::extension_elements

    source

    DataStoreReference::from_element

    source
    fn DataStoreReference::from_element(element : Element) -> DataStoreReference?

    DataStoreReference::id

    source
    fn DataStoreReference::id(self : DataStoreReference) -> Field[String]

    DataStoreReference::item_subject_ref

    source
    fn DataStoreReference::item_subject_ref(self : DataStoreReference) -> Field[Reference]

    DataStoreReference::monitoring

    source

    DataStoreReference::name

    source
    fn DataStoreReference::name(self : DataStoreReference) -> Field[String]

    DataStoreReference::new

    source
    fn DataStoreReference::new(id? : String, name? : String, item_subject_ref? : Reference, data_store_ref? : Reference, contents? : ArrayView[Content]) -> DataStoreReference

    DataStoreReference::not_equal

    source

    DataStoreReference::to_repr

    source

    DcBounds

    source
    pub struct DcBounds {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema Bounds.

    DcBounds::equal

    source
    fn DcBounds::equal(DcBounds, DcBounds) -> Bool

    DcBounds::from_element

    source
    fn DcBounds::from_element(element : Element) -> DcBounds?

    DcBounds::height

    source
    fn DcBounds::height(self : DcBounds) -> Field[ExactNumber]

    DcBounds::new

    source
    fn DcBounds::new(x? : ExactNumber, y? : ExactNumber, width? : ExactNumber, height? : ExactNumber, contents? : ArrayView[Content]) -> DcBounds

    DcBounds::not_equal

    source
    fn DcBounds::not_equal(x : DcBounds, y : DcBounds) -> Bool

    DcBounds::to_repr

    source

    DcBounds::width

    source
    fn DcBounds::width(self : DcBounds) -> Field[ExactNumber]

    DcBounds::x

    source

    DcBounds::y

    source

    DcFont

    source
    pub struct DcFont {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema Font.

    DcFont::equal

    source
    fn DcFont::equal(DcFont, DcFont) -> Bool

    DcFont::from_element

    source
    fn DcFont::from_element(element : Element) -> DcFont?

    DcFont::is_bold

    source
    fn DcFont::is_bold(self : DcFont) -> Field[Bool]

    DcFont::is_italic

    source
    fn DcFont::is_italic(self : DcFont) -> Field[Bool]

    DcFont::is_strike_through

    source
    fn DcFont::is_strike_through(self : DcFont) -> Field[Bool]

    DcFont::is_underline

    source
    fn DcFont::is_underline(self : DcFont) -> Field[Bool]

    DcFont::name

    source
    fn DcFont::name(self : DcFont) -> Field[String]

    DcFont::new

    source
    fn DcFont::new(name? : String, size? : ExactNumber, is_bold? : Bool, is_italic? : Bool, is_underline? : Bool, is_strike_through? : Bool, contents? : ArrayView[Content]) -> DcFont

    DcFont::not_equal

    source
    fn DcFont::not_equal(x : DcFont, y : DcFont) -> Bool

    DcFont::size

    source
    fn DcFont::size(self : DcFont) -> Field[ExactNumber]

    DcFont::to_repr

    source

    DcPoint

    source
    pub struct DcPoint {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema Point.

    DcPoint::equal

    source
    fn DcPoint::equal(DcPoint, DcPoint) -> Bool

    DcPoint::from_element

    source
    fn DcPoint::from_element(element : Element) -> DcPoint?

    DcPoint::new

    source
    fn DcPoint::new(x? : ExactNumber, y? : ExactNumber, contents? : ArrayView[Content]) -> DcPoint

    DcPoint::not_equal

    source
    fn DcPoint::not_equal(x : DcPoint, y : DcPoint) -> Bool

    DcPoint::to_repr

    source

    DcPoint::x

    source
    fn DcPoint::x(self : DcPoint) -> Field[ExactNumber]

    DcPoint::y

    source
    fn DcPoint::y(self : DcPoint) -> Field[ExactNumber]

    Definitions

    source
    pub struct Definitions {
      element : Element
    } derive(Eq, 
    Debug    )

    A definitions root. Children retain the caller's containment order; schema validation is separate from construction and serialization.

    Definitions::document

    source
    fn Definitions::document(self : Definitions) -> Document

    Definitions::equal

    source
    fn Definitions::equal(Definitions, Definitions) -> Bool

    Definitions::exporter

    source
    fn Definitions::exporter(self : Definitions) -> Field[String]

    Definitions::exporter_version

    source
    fn Definitions::exporter_version(self : Definitions) -> Field[String]

    Definitions::expression_language

    source
    fn Definitions::expression_language(self : Definitions) -> Field[String]

    Definitions::from_element

    source
    fn Definitions::from_element(element : Element) -> Definitions?

    Definitions::id

    source
    fn Definitions::id(self : Definitions) -> Field[String]

    Definitions::imports

    source
    fn Definitions::imports(self : Definitions) -> ReadOnlyArray[Import]

    Definitions::name

    source
    fn Definitions::name(self : Definitions) -> Field[String]

    Definitions::new

    source
    fn Definitions::new(target_namespace_uri : String, id? : String, name? : String, expression_language? : String, type_language? : String, exporter? : String, exporter_version? : String, children? : ArrayView[Element]) -> Definitions

    Definitions::not_equal

    source
    fn Definitions::not_equal(x : Definitions, y : Definitions) -> Bool

    Definitions::roots

    source
    fn Definitions::roots(self : Definitions) -> ReadOnlyArray[RootElement]

    Definitions::target_namespace

    source
    fn Definitions::target_namespace(self : Definitions) -> Field[String]

    Definitions::to_repr

    source

    Definitions::type_language

    source
    fn Definitions::type_language(self : Definitions) -> Field[String]

    DiAnonymousDiagramElementExtension1

    source
    pub struct DiAnonymousDiagramElementExtension1 {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema Anonymous_DiagramElement_extension_1.

    DiAnonymousDiagramElementExtension1::equal

    source

    DiAnonymousDiagramElementExtension1::from_element

    source

    DiAnonymousDiagramElementExtension1::not_equal

    source

    DiAnonymousDiagramElementExtension1::to_repr

    source

    DiDiagram

    source
    pub struct DiDiagram {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema Diagram.

    DiDiagram::documentation

    source
    fn DiDiagram::documentation(self : DiDiagram) -> Field[String]

    DiDiagram::equal

    source
    fn DiDiagram::equal(DiDiagram, DiDiagram) -> Bool

    DiDiagram::from_element

    source
    fn DiDiagram::from_element(element : Element) -> DiDiagram?

    DiDiagram::id

    source
    fn DiDiagram::id(self : DiDiagram) -> Field[String]

    DiDiagram::name

    source
    fn DiDiagram::name(self : DiDiagram) -> Field[String]

    DiDiagram::not_equal

    source
    fn DiDiagram::not_equal(x : DiDiagram, y : DiDiagram) -> Bool

    DiDiagram::resolution

    source
    fn DiDiagram::resolution(self : DiDiagram) -> Field[ExactNumber]

    DiDiagram::to_repr

    source

    DiDiagramElement

    source
    pub struct DiDiagramElement {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema DiagramElement.

    DiDiagramElement::equal

    source

    DiDiagramElement::extension

    source

    DiDiagramElement::from_element

    source
    fn DiDiagramElement::from_element(element : Element) -> DiDiagramElement?

    DiDiagramElement::id

    source
    fn DiDiagramElement::id(self : DiDiagramElement) -> Field[String]

    DiDiagramElement::not_equal

    source
    fn DiDiagramElement::not_equal(x : DiDiagramElement, y : DiDiagramElement) -> Bool

    DiDiagramElement::to_repr

    source

    DiEdge

    source
    pub struct DiEdge {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema Edge.

    DiEdge::equal

    source
    fn DiEdge::equal(DiEdge, DiEdge) -> Bool

    DiEdge::extension

    source

    DiEdge::from_element

    source
    fn DiEdge::from_element(element : Element) -> DiEdge?

    DiEdge::id

    source
    fn DiEdge::id(self : DiEdge) -> Field[String]

    DiEdge::not_equal

    source
    fn DiEdge::not_equal(x : DiEdge, y : DiEdge) -> Bool

    DiEdge::to_repr

    source

    DiEdge::waypoint

    source
    fn DiEdge::waypoint(self : DiEdge) -> Field[ReadOnlyArray[DcPoint]]

    DiLabel

    source
    pub struct DiLabel {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema Label.

    DiLabel::bounds

    source
    fn DiLabel::bounds(self : DiLabel) -> Field[DcBounds]

    DiLabel::equal

    source
    fn DiLabel::equal(DiLabel, DiLabel) -> Bool

    DiLabel::extension

    source

    DiLabel::from_element

    source
    fn DiLabel::from_element(element : Element) -> DiLabel?

    DiLabel::id

    source
    fn DiLabel::id(self : DiLabel) -> Field[String]

    DiLabel::not_equal

    source
    fn DiLabel::not_equal(x : DiLabel, y : DiLabel) -> Bool

    DiLabel::to_repr

    source

    DiLabeledEdge

    source
    pub struct DiLabeledEdge {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema LabeledEdge.

    DiLabeledEdge::equal

    source

    DiLabeledEdge::extension

    source

    DiLabeledEdge::from_element

    source
    fn DiLabeledEdge::from_element(element : Element) -> DiLabeledEdge?

    DiLabeledEdge::id

    source
    fn DiLabeledEdge::id(self : DiLabeledEdge) -> Field[String]

    DiLabeledEdge::not_equal

    source
    fn DiLabeledEdge::not_equal(x : DiLabeledEdge, y : DiLabeledEdge) -> Bool

    DiLabeledEdge::to_repr

    source

    DiLabeledEdge::waypoint

    source
    fn DiLabeledEdge::waypoint(self : DiLabeledEdge) -> Field[ReadOnlyArray[DcPoint]]

    DiLabeledShape

    source
    pub struct DiLabeledShape {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema LabeledShape.

    DiLabeledShape::bounds

    source

    DiLabeledShape::equal

    source

    DiLabeledShape::extension

    source

    DiLabeledShape::from_element

    source
    fn DiLabeledShape::from_element(element : Element) -> DiLabeledShape?

    DiLabeledShape::id

    source
    fn DiLabeledShape::id(self : DiLabeledShape) -> Field[String]

    DiLabeledShape::not_equal

    source
    fn DiLabeledShape::not_equal(x : DiLabeledShape, y : DiLabeledShape) -> Bool

    DiLabeledShape::to_repr

    source

    DiNode

    source
    pub struct DiNode {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema Node.

    DiNode::equal

    source
    fn DiNode::equal(DiNode, DiNode) -> Bool

    DiNode::extension

    source

    DiNode::from_element

    source
    fn DiNode::from_element(element : Element) -> DiNode?

    DiNode::id

    source
    fn DiNode::id(self : DiNode) -> Field[String]

    DiNode::not_equal

    source
    fn DiNode::not_equal(x : DiNode, y : DiNode) -> Bool

    DiNode::to_repr

    source

    DiPlane

    source
    pub struct DiPlane {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema Plane.

    DiPlane::diagram_element

    source
    fn DiPlane::diagram_element(self : DiPlane) -> Field[ReadOnlyArray[DiDiagramElement]]

    DiPlane::equal

    source
    fn DiPlane::equal(DiPlane, DiPlane) -> Bool

    DiPlane::extension

    source

    DiPlane::from_element

    source
    fn DiPlane::from_element(element : Element) -> DiPlane?

    DiPlane::id

    source
    fn DiPlane::id(self : DiPlane) -> Field[String]

    DiPlane::not_equal

    source
    fn DiPlane::not_equal(x : DiPlane, y : DiPlane) -> Bool

    DiPlane::to_repr

    source

    DiShape

    source
    pub struct DiShape {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema Shape.

    DiShape::bounds

    source
    fn DiShape::bounds(self : DiShape) -> Field[DcBounds]

    DiShape::equal

    source
    fn DiShape::equal(DiShape, DiShape) -> Bool

    DiShape::extension

    source

    DiShape::from_element

    source
    fn DiShape::from_element(element : Element) -> DiShape?

    DiShape::id

    source
    fn DiShape::id(self : DiShape) -> Field[String]

    DiShape::not_equal

    source
    fn DiShape::not_equal(x : DiShape, y : DiShape) -> Bool

    DiShape::to_repr

    source

    DiStyle

    source
    pub struct DiStyle {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema Style.

    DiStyle::equal

    source
    fn DiStyle::equal(DiStyle, DiStyle) -> Bool

    DiStyle::from_element

    source
    fn DiStyle::from_element(element : Element) -> DiStyle?

    DiStyle::id

    source
    fn DiStyle::id(self : DiStyle) -> Field[String]

    DiStyle::not_equal

    source
    fn DiStyle::not_equal(x : DiStyle, y : DiStyle) -> Bool

    DiStyle::to_repr

    source

    Diagnostic

    source
    pub struct Diagnostic {
      code : String
      severity : Severity
      message : String
      span : Span?
      location : Location?
    } derive(Eq, 
    Debug    )

    Diagnostic::equal

    source
    fn Diagnostic::equal(Diagnostic, Diagnostic) -> Bool

    Diagnostic::not_equal

    source
    fn Diagnostic::not_equal(x : Diagnostic, y : Diagnostic) -> Bool

    Diagnostic::to_repr

    source

    Document

    source
    pub struct Document {
      root : Element
      prolog : ReadOnlyArray[Content]
      epilog : ReadOnlyArray[Content]
      // private fields
    } derive(
    Debug    )

    The typed document owns its root and ordered prolog/epilog data. Source maps remain separate from semantic equality and are absent on constructed values.
    impl Eq for Document

    Document::definitions

    source
    fn Document::definitions(self : Document) -> Definitions?

    Document::equal

    source
    fn Document::equal(a : Document, b : Document) -> Bool

    Document::new

    source
    fn Document::new(root : Element, prolog? : ArrayView[Content], epilog? : ArrayView[Content]) -> Document

    Document::not_equal

    source
    fn Document::not_equal(x : Document, y : Document) -> Bool

    Document::to_repr

    source

    Document::walk

    source
    fn Document::walk(self : Document, visit : (Element) -> Unit) -> Unit

    DocumentGraph

    source
    pub struct DocumentGraph {
      nodes : ReadOnlyArray[GraphNode]
      edges : ReadOnlyArray[GraphEdge]
      // private fields
    }

    DocumentGraph::lookup

    source
    fn DocumentGraph::lookup(self : DocumentGraph, endpoint : GraphEndpoint, limits? : GraphLimits) -> Result[GraphNode, GraphFailure]

    DocumentGraph::new

    source
    fn DocumentGraph::new(document : Document, resources? : ResourceSet, resource_id? : String, limits? : Limits, graph_limits? : GraphLimits) -> GraphBuildResult

    Index the document and its explicit resource closure once. Semantic findings coexist with a graph; a query fails when it encounters an invalid selected reference. Processing exhaustion never exposes an apparently complete graph.

    DocumentGraph::reachable

    source
    fn DocumentGraph::reachable(self : DocumentGraph, start : GraphEndpoint, kinds? : ArrayView[GraphEdgeKind], direction? : GraphDirection, limits? : GraphLimits) -> ReachabilityResult

    Breadth-first discovery, including the start once. References, coordinates and XML order never create implicit control-flow edges.

    DocumentGraph::route

    source
    fn DocumentGraph::route(self : DocumentGraph, start : GraphEndpoint, target : GraphEndpoint, kinds? : ArrayView[GraphEdgeKind], direction? : GraphDirection, limits? : GraphLimits) -> RouteResult

    One shortest route. The first differing authored connection in document order breaks ties. Reverse traversal keeps authored edge endpoints intact.

    DocumentGraph::to_repr

    source

    DocumentIndex

    source
    pub struct DocumentIndex {
      document : Document
      nodes : ReadOnlyArray[IndexedElement]
      complete : Bool
      // private fields
    } derive(
    Debug    )

    Immutable source-order index. Duplicate occurrences are never overwritten.

    DocumentIndex::lookup

    source
    fn DocumentIndex::lookup(self : DocumentIndex, id : String) -> IdLookup

    DocumentIndex::to_repr

    source

    DocumentResource

    source
    pub struct DocumentResource {
      location : String
      document : Document
    } derive(Eq, 
    Debug    )

    DocumentResource::equal

    source

    DocumentResource::new

    source
    fn DocumentResource::new(location : String, document : Document) -> DocumentResource

    DocumentResource::not_equal

    source
    fn DocumentResource::not_equal(x : DocumentResource, y : DocumentResource) -> Bool

    DocumentResource::to_repr

    source

    DocumentTree

    source
    pub struct DocumentTree {
      document : Document
      // private fields
    }

    DocumentTree::length

    source
    fn DocumentTree::length(self : DocumentTree) -> Int

    DocumentTree::lookup

    source
    fn DocumentTree::lookup(self : DocumentTree, handle : NodeHandle) -> NodeLookup

    DocumentTree::new

    source
    fn DocumentTree::new(document : Document, resource_id? : String, limits? : Limits) -> TreeBuildResult

    DocumentTree::resource_id

    source
    fn DocumentTree::resource_id(self : DocumentTree) -> String?

    DocumentTree::root

    source
    fn DocumentTree::root(self : DocumentTree) -> NodeRef

    DocumentTree::to_repr

    source

    Documentation

    source
    pub struct Documentation {
      element : Element
    } derive(Eq, 
    Debug    )

    Documentation::equal

    source

    Documentation::from_element

    source
    fn Documentation::from_element(element : Element) -> Documentation?

    Documentation::id

    source
    fn Documentation::id(self : Documentation) -> Field[String]

    Documentation::new

    source
    fn Documentation::new(contents : ArrayView[Content], id? : String, text_format? : String) -> Documentation

    Documentation::not_equal

    source
    fn Documentation::not_equal(x : Documentation, y : Documentation) -> Bool

    Documentation::text_format

    source
    fn Documentation::text_format(self : Documentation) -> Field[String]

    Documentation::to_repr

    source

    Element

    source
    pub struct Element {
      kind : Kind
      attributes : ReadOnlyArray[(String, String)]
      values : ReadOnlyArray[Attribute]
      children : ReadOnlyArray[Element]
      contents : ReadOnlyArray[Content]
      content : String
      bindings : ReadOnlyArray[(String, String)]
      value_type : ExpandedName?
      text_value : Scalar?
      span : Span?
      // private fields
    } derive(
    Debug    )

    Immutable document element with schema-typed attribute and scalar values. The legacy string attributes expose model tokens; lexical source is in CST.
    impl Eq for Element

    Element::attribute

    source
    fn Element::attribute(self : Element, name : String) -> String?

    Element::boolean

    source
    fn Element::boolean(self : Element, name : String) -> Field[Bool]

    Element::enumeration

    source
    fn Element::enumeration(self : Element, name : String) -> Field[BpmnEnum]

    Element::equal

    source
    fn Element::equal(a : Element, b : Element) -> Bool

    Element::from_values

    source
    fn Element::from_values(kind : Kind, values? : ArrayView[Attribute], contents? : ArrayView[Content], bindings? : ArrayView[(String, String)], value_type? : ExpandedName, text_value? : Scalar) -> Element

    Element::integer

    source
    fn Element::integer(self : Element, name : String) -> Field[ExactInteger]

    Element::location

    source
    fn Element::location(self : Element) -> Location?

    Element::namespace_binding

    source
    fn Element::namespace_binding(self : Element, prefix : String) -> String?

    Element::new

    source
    fn Element::new(kind : Kind, attributes? : ArrayView[(String, String)], children? : ArrayView[Element], content? : String, bindings? : ArrayView[(String, String)], value_type? : ExpandedName) -> Element

    A compatibility constructor for string attributes and text followed by children. QName spellings use the explicit bindings of this value. Typed references can instead be constructed directly from expanded identity with from_values.

    Element::not_equal

    source
    fn Element::not_equal(x : Element, y : Element) -> Bool

    Element::number

    source
    fn Element::number(self : Element, name : String) -> Field[ExactNumber]

    Element::opaque_attributes

    source
    fn Element::opaque_attributes(self : Element) -> ReadOnlyArray[Attribute]

    Element::reference

    source
    fn Element::reference(self : Element, name : String) -> Field[Reference]

    Element::scalar

    source
    fn Element::scalar(self : Element, name : ExpandedName) -> Scalar?

    Element::string

    source
    fn Element::string(self : Element, name : String) -> Field[String]

    Element::to_repr

    source

    Element::with_attribute

    source
    fn Element::with_attribute(self : Element, attribute : Attribute) -> Element

    Element::with_contents

    source
    fn Element::with_contents(self : Element, contents : ArrayView[Content]) -> Element

    Element::with_kind

    source
    fn Element::with_kind(self : Element, kind : Kind) -> Element

    Element::xml

    source
    fn Element::xml(self : Element) -> XmlElement?

    EndEvent

    source
    pub struct EndEvent {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tEndEvent.

    EndEvent::auditing

    source
    fn EndEvent::auditing(self : EndEvent) -> Field[Auditing]

    EndEvent::category_value_ref

    source
    fn EndEvent::category_value_ref(self : EndEvent) -> Field[ReadOnlyArray[Reference]]

    EndEvent::data_input

    source
    fn EndEvent::data_input(self : EndEvent) -> Field[ReadOnlyArray[DataInput]]

    EndEvent::data_input_association

    source
    fn EndEvent::data_input_association(self : EndEvent) -> Field[ReadOnlyArray[DataInputAssociation]]

    EndEvent::documentation

    source
    fn EndEvent::documentation(self : EndEvent) -> Field[ReadOnlyArray[Documentation]]

    EndEvent::equal

    source
    fn EndEvent::equal(EndEvent, EndEvent) -> Bool

    EndEvent::event_definition

    source
    fn EndEvent::event_definition(self : EndEvent) -> Field[ReadOnlyArray[EventDefinition]]

    EndEvent::event_definition_ref

    source
    fn EndEvent::event_definition_ref(self : EndEvent) -> Field[ReadOnlyArray[Reference]]

    EndEvent::extension_elements

    source
    fn EndEvent::extension_elements(self : EndEvent) -> Field[ExtensionElements]

    EndEvent::from_element

    source
    fn EndEvent::from_element(element : Element) -> EndEvent?

    EndEvent::id

    source
    fn EndEvent::id(self : EndEvent) -> Field[String]

    EndEvent::incoming

    source
    fn EndEvent::incoming(self : EndEvent) -> Field[ReadOnlyArray[Reference]]

    EndEvent::input_set

    source
    fn EndEvent::input_set(self : EndEvent) -> Field[InputSet]

    EndEvent::monitoring

    source
    fn EndEvent::monitoring(self : EndEvent) -> Field[Monitoring]

    EndEvent::name

    source
    fn EndEvent::name(self : EndEvent) -> Field[String]

    EndEvent::new

    source
    fn EndEvent::new(id? : String, name? : String, contents? : ArrayView[Content]) -> EndEvent

    EndEvent::not_equal

    source
    fn EndEvent::not_equal(x : EndEvent, y : EndEvent) -> Bool

    EndEvent::outgoing

    source
    fn EndEvent::outgoing(self : EndEvent) -> Field[ReadOnlyArray[Reference]]

    EndEvent::property

    source
    fn EndEvent::property(self : EndEvent) -> Field[ReadOnlyArray[Property]]

    EndEvent::to_repr

    source

    EndPoint

    source
    pub struct EndPoint {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tEndPoint.

    EndPoint::documentation

    source
    fn EndPoint::documentation(self : EndPoint) -> Field[ReadOnlyArray[Documentation]]

    EndPoint::equal

    source
    fn EndPoint::equal(EndPoint, EndPoint) -> Bool

    EndPoint::extension_elements

    source
    fn EndPoint::extension_elements(self : EndPoint) -> Field[ExtensionElements]

    EndPoint::from_element

    source
    fn EndPoint::from_element(element : Element) -> EndPoint?

    EndPoint::id

    source
    fn EndPoint::id(self : EndPoint) -> Field[String]

    EndPoint::new

    source
    fn EndPoint::new(id? : String, contents? : ArrayView[Content]) -> EndPoint

    EndPoint::not_equal

    source
    fn EndPoint::not_equal(x : EndPoint, y : EndPoint) -> Bool

    EndPoint::to_repr

    source

    ErrorEventDefinition

    source
    pub struct ErrorEventDefinition {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tErrorEventDefinition.

    ErrorEventDefinition::documentation

    source
    fn ErrorEventDefinition::documentation(self : ErrorEventDefinition) -> Field[ReadOnlyArray[Documentation]]

    ErrorEventDefinition::equal

    source

    ErrorEventDefinition::error_ref

    source

    ErrorEventDefinition::extension_elements

    source

    ErrorEventDefinition::from_element

    source
    fn ErrorEventDefinition::from_element(element : Element) -> ErrorEventDefinition?

    ErrorEventDefinition::id

    source

    ErrorEventDefinition::new

    source
    fn ErrorEventDefinition::new(id? : String, error_ref? : Reference, contents? : ArrayView[Content]) -> ErrorEventDefinition

    ErrorEventDefinition::not_equal

    source

    ErrorEventDefinition::to_repr

    source

    Escalation

    source
    pub struct Escalation {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tEscalation.

    Escalation::documentation

    source
    fn Escalation::documentation(self : Escalation) -> Field[ReadOnlyArray[Documentation]]

    Escalation::equal

    source
    fn Escalation::equal(Escalation, Escalation) -> Bool

    Escalation::escalation_code

    source
    fn Escalation::escalation_code(self : Escalation) -> Field[String]

    Escalation::extension_elements

    source
    fn Escalation::extension_elements(self : Escalation) -> Field[ExtensionElements]

    Escalation::from_element

    source
    fn Escalation::from_element(element : Element) -> Escalation?

    Escalation::id

    source
    fn Escalation::id(self : Escalation) -> Field[String]

    Escalation::name

    source
    fn Escalation::name(self : Escalation) -> Field[String]

    Escalation::new

    source
    fn Escalation::new(id? : String, name? : String, escalation_code? : String, structure_ref? : Reference, contents? : ArrayView[Content]) -> Escalation

    Escalation::not_equal

    source
    fn Escalation::not_equal(x : Escalation, y : Escalation) -> Bool

    Escalation::structure_ref

    source
    fn Escalation::structure_ref(self : Escalation) -> Field[Reference]

    Escalation::to_repr

    source

    EscalationEventDefinition

    source
    pub struct EscalationEventDefinition {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tEscalationEventDefinition.

    EscalationEventDefinition::documentation

    source
    fn EscalationEventDefinition::documentation(self : EscalationEventDefinition) -> Field[ReadOnlyArray[Documentation]]

    EscalationEventDefinition::equal

    source

    EscalationEventDefinition::escalation_ref

    source

    EscalationEventDefinition::extension_elements

    source

    EscalationEventDefinition::from_element

    source

    EscalationEventDefinition::id

    source

    EscalationEventDefinition::new

    source
    fn EscalationEventDefinition::new(id? : String, escalation_ref? : Reference, contents? : ArrayView[Content]) -> EscalationEventDefinition

    EscalationEventDefinition::not_equal

    source

    EscalationEventDefinition::to_repr

    source

    Event

    source
    pub struct Event {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tEvent.

    Event::auditing

    source
    fn Event::auditing(self : Event) -> Field[Auditing]

    Event::category_value_ref

    source
    fn Event::category_value_ref(self : Event) -> Field[ReadOnlyArray[Reference]]

    Event::documentation

    source
    fn Event::documentation(self : Event) -> Field[ReadOnlyArray[Documentation]]

    Event::equal

    source
    fn Event::equal(Event, Event) -> Bool

    Event::extension_elements

    source
    fn Event::extension_elements(self : Event) -> Field[ExtensionElements]

    Event::from_element

    source
    fn Event::from_element(element : Element) -> Event?

    Event::id

    source
    fn Event::id(self : Event) -> Field[String]

    Event::incoming

    source
    fn Event::incoming(self : Event) -> Field[ReadOnlyArray[Reference]]

    Event::monitoring

    source
    fn Event::monitoring(self : Event) -> Field[Monitoring]

    Event::name

    source
    fn Event::name(self : Event) -> Field[String]

    Event::not_equal

    source
    fn Event::not_equal(x : Event, y : Event) -> Bool

    Event::outgoing

    source
    fn Event::outgoing(self : Event) -> Field[ReadOnlyArray[Reference]]

    Event::property

    source
    fn Event::property(self : Event) -> Field[ReadOnlyArray[Property]]

    Event::to_repr

    source

    EventBasedGateway

    source
    pub struct EventBasedGateway {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tEventBasedGateway.

    EventBasedGateway::auditing

    source

    EventBasedGateway::category_value_ref

    source
    fn EventBasedGateway::category_value_ref(self : EventBasedGateway) -> Field[ReadOnlyArray[Reference]]

    EventBasedGateway::documentation

    source
    fn EventBasedGateway::documentation(self : EventBasedGateway) -> Field[ReadOnlyArray[Documentation]]

    EventBasedGateway::equal

    source

    EventBasedGateway::event_gateway_type

    source

    EventBasedGateway::extension_elements

    source
    fn EventBasedGateway::extension_elements(self : EventBasedGateway) -> Field[ExtensionElements]

    EventBasedGateway::from_element

    source
    fn EventBasedGateway::from_element(element : Element) -> EventBasedGateway?

    EventBasedGateway::gateway_direction

    source
    fn EventBasedGateway::gateway_direction(self : EventBasedGateway) -> Field[GatewayDirection]

    EventBasedGateway::id

    source
    fn EventBasedGateway::id(self : EventBasedGateway) -> Field[String]

    EventBasedGateway::incoming

    source
    fn EventBasedGateway::incoming(self : EventBasedGateway) -> Field[ReadOnlyArray[Reference]]

    EventBasedGateway::instantiate

    source
    fn EventBasedGateway::instantiate(self : EventBasedGateway) -> Field[Bool]

    EventBasedGateway::monitoring

    source

    EventBasedGateway::name

    source
    fn EventBasedGateway::name(self : EventBasedGateway) -> Field[String]

    EventBasedGateway::new

    source
    fn EventBasedGateway::new(id? : String, name? : String, gateway_direction? : GatewayDirection, instantiate? : Bool, event_gateway_type? : EventBasedGatewayType, contents? : ArrayView[Content]) -> EventBasedGateway

    EventBasedGateway::not_equal

    source
    fn EventBasedGateway::not_equal(x : EventBasedGateway, y : EventBasedGateway) -> Bool

    EventBasedGateway::outgoing

    source
    fn EventBasedGateway::outgoing(self : EventBasedGateway) -> Field[ReadOnlyArray[Reference]]

    EventBasedGateway::to_repr

    source

    EventBasedGatewayType

    source
    pub(all) enum EventBasedGatewayType {
      Exclusive
      Parallel
    } derive(Eq, 
    Debug    )

    Values of the pinned XSD type tEventBasedGatewayType.

    EventBasedGatewayType::equal

    source

    EventBasedGatewayType::not_equal

    source

    EventBasedGatewayType::parse

    source
    fn EventBasedGatewayType::parse(token : String) -> EventBasedGatewayType?

    EventBasedGatewayType::to_repr

    source

    EventBasedGatewayType::token

    source
    fn EventBasedGatewayType::token(self : EventBasedGatewayType) -> String

    EventDefinition

    source
    pub struct EventDefinition {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tEventDefinition.

    EventDefinition::documentation

    source
    fn EventDefinition::documentation(self : EventDefinition) -> Field[ReadOnlyArray[Documentation]]

    EventDefinition::equal

    source

    EventDefinition::extension_elements

    source
    fn EventDefinition::extension_elements(self : EventDefinition) -> Field[ExtensionElements]

    EventDefinition::from_element

    source
    fn EventDefinition::from_element(element : Element) -> EventDefinition?

    EventDefinition::id

    source
    fn EventDefinition::id(self : EventDefinition) -> Field[String]

    EventDefinition::not_equal

    source
    fn EventDefinition::not_equal(x : EventDefinition, y : EventDefinition) -> Bool

    EventDefinition::to_repr

    source

    EventReader

    source
    pub struct EventReader {
      // private fields
    }

    EventReader::iter

    source

    EventReader::new

    source
    fn EventReader::new(root : NodeRef) -> EventReader

    EventReader::next

    source

    EventReader::skip_children

    source
    fn EventReader::skip_children(self : EventReader) -> Unit

    EventReader::stop

    source
    fn EventReader::stop(self : EventReader) -> Unit

    ExactInteger

    source
    pub struct ExactInteger {
      token : String
    } derive(Eq, 
    Debug    )

    ExactInteger::equal

    source

    ExactInteger::not_equal

    source
    fn ExactInteger::not_equal(x : ExactInteger, y : ExactInteger) -> Bool

    ExactInteger::parse

    source
    fn ExactInteger::parse(token : String) -> ExactInteger?

    ExactInteger::to_repr

    source

    ExactNumber

    source
    pub struct ExactNumber {
      token : String
    } derive(Eq, 
    Debug    )

    An exact XML Schema numeric token. It is never converted through a host float.

    ExactNumber::equal

    source
    fn ExactNumber::equal(ExactNumber, ExactNumber) -> Bool

    ExactNumber::is_finite

    source
    fn ExactNumber::is_finite(self : ExactNumber) -> Bool

    ExactNumber::not_equal

    source
    fn ExactNumber::not_equal(x : ExactNumber, y : ExactNumber) -> Bool

    ExactNumber::parse

    source
    fn ExactNumber::parse(token : String) -> ExactNumber?

    ExactNumber::to_repr

    source

    ExclusiveGateway

    source
    pub struct ExclusiveGateway {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tExclusiveGateway.

    ExclusiveGateway::auditing

    source

    ExclusiveGateway::category_value_ref

    source
    fn ExclusiveGateway::category_value_ref(self : ExclusiveGateway) -> Field[ReadOnlyArray[Reference]]

    ExclusiveGateway::default_

    source

    ExclusiveGateway::documentation

    source
    fn ExclusiveGateway::documentation(self : ExclusiveGateway) -> Field[ReadOnlyArray[Documentation]]

    ExclusiveGateway::equal

    source

    ExclusiveGateway::extension_elements

    source
    fn ExclusiveGateway::extension_elements(self : ExclusiveGateway) -> Field[ExtensionElements]

    ExclusiveGateway::from_element

    source
    fn ExclusiveGateway::from_element(element : Element) -> ExclusiveGateway?

    ExclusiveGateway::gateway_direction

    source
    fn ExclusiveGateway::gateway_direction(self : ExclusiveGateway) -> Field[GatewayDirection]

    ExclusiveGateway::id

    source
    fn ExclusiveGateway::id(self : ExclusiveGateway) -> Field[String]

    ExclusiveGateway::incoming

    source
    fn ExclusiveGateway::incoming(self : ExclusiveGateway) -> Field[ReadOnlyArray[Reference]]

    ExclusiveGateway::monitoring

    source

    ExclusiveGateway::name

    source
    fn ExclusiveGateway::name(self : ExclusiveGateway) -> Field[String]

    ExclusiveGateway::new

    source
    fn ExclusiveGateway::new(id? : String, name? : String, gateway_direction? : GatewayDirection, default_? : Reference, contents? : ArrayView[Content]) -> ExclusiveGateway

    ExclusiveGateway::not_equal

    source
    fn ExclusiveGateway::not_equal(x : ExclusiveGateway, y : ExclusiveGateway) -> Bool

    ExclusiveGateway::outgoing

    source
    fn ExclusiveGateway::outgoing(self : ExclusiveGateway) -> Field[ReadOnlyArray[Reference]]

    ExclusiveGateway::to_repr

    source

    ExpandedName

    source
    pub struct ExpandedName {
      namespace_uri : String
      local_name : String
    } derive(Eq, 
    Debug    )

    ExpandedName::equal

    source

    ExpandedName::new

    source
    fn ExpandedName::new(namespace_uri : String, local_name : String) -> ExpandedName

    Names are values; writer validation checks constructed names and bindings.

    ExpandedName::not_equal

    source
    fn ExpandedName::not_equal(x : ExpandedName, y : ExpandedName) -> Bool

    ExpandedName::to_repr

    source

    Expression

    source
    pub struct Expression {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tExpression.

    Expression::documentation

    source
    fn Expression::documentation(self : Expression) -> Field[ReadOnlyArray[Documentation]]

    Expression::equal

    source
    fn Expression::equal(Expression, Expression) -> Bool

    Expression::extension_elements

    source
    fn Expression::extension_elements(self : Expression) -> Field[ExtensionElements]

    Expression::from_element

    source
    fn Expression::from_element(element : Element) -> Expression?

    Expression::id

    source
    fn Expression::id(self : Expression) -> Field[String]

    Expression::new

    source
    fn Expression::new(id? : String, contents? : ArrayView[Content]) -> Expression

    Expression::not_equal

    source
    fn Expression::not_equal(x : Expression, y : Expression) -> Bool

    Expression::to_repr

    source

    Extension

    source
    pub struct Extension {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tExtension.

    Extension::definition

    source
    fn Extension::definition(self : Extension) -> Field[Reference]

    Extension::documentation

    source
    fn Extension::documentation(self : Extension) -> Field[ReadOnlyArray[Documentation]]

    Extension::equal

    source
    fn Extension::equal(Extension, Extension) -> Bool

    Extension::from_element

    source
    fn Extension::from_element(element : Element) -> Extension?

    Extension::must_understand

    source
    fn Extension::must_understand(self : Extension) -> Field[Bool]

    Extension::new

    source
    fn Extension::new(definition? : Reference, must_understand? : Bool, contents? : ArrayView[Content]) -> Extension

    Extension::not_equal

    source
    fn Extension::not_equal(x : Extension, y : Extension) -> Bool

    Extension::to_repr

    source

    ExtensionElements

    source
    pub struct ExtensionElements {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tExtensionElements.

    ExtensionElements::equal

    source

    ExtensionElements::from_element

    source
    fn ExtensionElements::from_element(element : Element) -> ExtensionElements?

    ExtensionElements::new

    source

    ExtensionElements::not_equal

    source
    fn ExtensionElements::not_equal(x : ExtensionElements, y : ExtensionElements) -> Bool

    ExtensionElements::to_repr

    source

    ExternalNode

    source
    pub struct ExternalNode {
      symbol : ResolvedSymbol
      occurrence : Int
    } derive(Eq, 
    Debug    )

    ExternalNode::equal

    source

    ExternalNode::not_equal

    source
    fn ExternalNode::not_equal(x : ExternalNode, y : ExternalNode) -> Bool

    ExternalNode::to_repr

    source

    ExternalResource

    source
    pub struct ExternalResource {
      location : String
      namespace_uri : String
      import_type : String
      symbols : ReadOnlyArray[String]
    } derive(Eq, 
    Debug    )

    Caller-supplied non-BPMN identities. This is an explicit symbol table, not an XML Schema, WSDL or vendor-language validator.

    ExternalResource::equal

    source

    ExternalResource::new

    source
    fn ExternalResource::new(location : String, namespace_uri : String, import_type : String, symbols : ArrayView[String]) -> ExternalResource

    ExternalResource::not_equal

    source
    fn ExternalResource::not_equal(x : ExternalResource, y : ExternalResource) -> Bool

    ExternalResource::to_repr

    source

    Field

    source
    pub(all) enum Field[T] {
      Absent
      Present(T)
      InvalidValue(Scalar)
    } derive(Eq, 
    Debug    )

    Absence is separate from a present false, empty string, zero or reference.

    Field::equal

    source
    fn[T : Eq] Field::equal(Field[T], Field[T]) -> Bool

    Field::not_equal

    source
    fn[T : Eq] Field::not_equal(x : Field[T], y : Field[T]) -> Bool

    Field::to_repr

    source

    Field::value

    source
    fn[T] Field::value(self : Field[T]) -> T?

    FlowElement

    source
    pub struct FlowElement {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tFlowElement.

    FlowElement::auditing

    source
    fn FlowElement::auditing(self : FlowElement) -> Field[Auditing]

    FlowElement::category_value_ref

    source
    fn FlowElement::category_value_ref(self : FlowElement) -> Field[ReadOnlyArray[Reference]]

    FlowElement::documentation

    source
    fn FlowElement::documentation(self : FlowElement) -> Field[ReadOnlyArray[Documentation]]

    FlowElement::equal

    source
    fn FlowElement::equal(FlowElement, FlowElement) -> Bool

    FlowElement::extension_elements

    source
    fn FlowElement::extension_elements(self : FlowElement) -> Field[ExtensionElements]

    FlowElement::from_element

    source
    fn FlowElement::from_element(element : Element) -> FlowElement?

    FlowElement::id

    source
    fn FlowElement::id(self : FlowElement) -> Field[String]

    FlowElement::monitoring

    source
    fn FlowElement::monitoring(self : FlowElement) -> Field[Monitoring]

    FlowElement::name

    source
    fn FlowElement::name(self : FlowElement) -> Field[String]

    FlowElement::not_equal

    source
    fn FlowElement::not_equal(x : FlowElement, y : FlowElement) -> Bool

    FlowElement::to_repr

    source

    FlowNode

    source
    pub struct FlowNode {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tFlowNode.

    FlowNode::auditing

    source
    fn FlowNode::auditing(self : FlowNode) -> Field[Auditing]

    FlowNode::category_value_ref

    source
    fn FlowNode::category_value_ref(self : FlowNode) -> Field[ReadOnlyArray[Reference]]

    FlowNode::documentation

    source
    fn FlowNode::documentation(self : FlowNode) -> Field[ReadOnlyArray[Documentation]]

    FlowNode::equal

    source
    fn FlowNode::equal(FlowNode, FlowNode) -> Bool

    FlowNode::extension_elements

    source
    fn FlowNode::extension_elements(self : FlowNode) -> Field[ExtensionElements]

    FlowNode::from_element

    source
    fn FlowNode::from_element(element : Element) -> FlowNode?

    FlowNode::id

    source
    fn FlowNode::id(self : FlowNode) -> Field[String]

    FlowNode::incoming

    source
    fn FlowNode::incoming(self : FlowNode) -> Field[ReadOnlyArray[Reference]]

    FlowNode::monitoring

    source
    fn FlowNode::monitoring(self : FlowNode) -> Field[Monitoring]

    FlowNode::name

    source
    fn FlowNode::name(self : FlowNode) -> Field[String]

    FlowNode::not_equal

    source
    fn FlowNode::not_equal(x : FlowNode, y : FlowNode) -> Bool

    FlowNode::outgoing

    source
    fn FlowNode::outgoing(self : FlowNode) -> Field[ReadOnlyArray[Reference]]

    FlowNode::to_repr

    source

    FormalExpression

    source
    pub struct FormalExpression {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tFormalExpression.

    FormalExpression::documentation

    source
    fn FormalExpression::documentation(self : FormalExpression) -> Field[ReadOnlyArray[Documentation]]

    FormalExpression::equal

    source

    FormalExpression::evaluates_to_type_ref

    source
    fn FormalExpression::evaluates_to_type_ref(self : FormalExpression) -> Field[Reference]

    FormalExpression::extension_elements

    source
    fn FormalExpression::extension_elements(self : FormalExpression) -> Field[ExtensionElements]

    FormalExpression::from_element

    source
    fn FormalExpression::from_element(element : Element) -> FormalExpression?

    FormalExpression::id

    source
    fn FormalExpression::id(self : FormalExpression) -> Field[String]

    FormalExpression::language

    source
    fn FormalExpression::language(self : FormalExpression) -> Field[String]

    FormalExpression::new

    source
    fn FormalExpression::new(id? : String, language? : String, evaluates_to_type_ref? : Reference, contents? : ArrayView[Content]) -> FormalExpression

    FormalExpression::not_equal

    source
    fn FormalExpression::not_equal(x : FormalExpression, y : FormalExpression) -> Bool

    FormalExpression::to_repr

    source

    Gateway

    source
    pub struct Gateway {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tGateway.

    Gateway::auditing

    source
    fn Gateway::auditing(self : Gateway) -> Field[Auditing]

    Gateway::category_value_ref

    source
    fn Gateway::category_value_ref(self : Gateway) -> Field[ReadOnlyArray[Reference]]

    Gateway::documentation

    source
    fn Gateway::documentation(self : Gateway) -> Field[ReadOnlyArray[Documentation]]

    Gateway::equal

    source
    fn Gateway::equal(Gateway, Gateway) -> Bool

    Gateway::extension_elements

    source
    fn Gateway::extension_elements(self : Gateway) -> Field[ExtensionElements]

    Gateway::from_element

    source
    fn Gateway::from_element(element : Element) -> Gateway?

    Gateway::gateway_direction

    source
    fn Gateway::gateway_direction(self : Gateway) -> Field[GatewayDirection]

    Gateway::id

    source
    fn Gateway::id(self : Gateway) -> Field[String]

    Gateway::incoming

    source
    fn Gateway::incoming(self : Gateway) -> Field[ReadOnlyArray[Reference]]

    Gateway::monitoring

    source
    fn Gateway::monitoring(self : Gateway) -> Field[Monitoring]

    Gateway::name

    source
    fn Gateway::name(self : Gateway) -> Field[String]

    Gateway::new

    source
    fn Gateway::new(id? : String, name? : String, gateway_direction? : GatewayDirection, contents? : ArrayView[Content]) -> Gateway

    Gateway::not_equal

    source
    fn Gateway::not_equal(x : Gateway, y : Gateway) -> Bool

    Gateway::outgoing

    source
    fn Gateway::outgoing(self : Gateway) -> Field[ReadOnlyArray[Reference]]

    Gateway::to_repr

    source

    GatewayDirection

    source
    pub(all) enum GatewayDirection {
      Unspecified
      Converging
      Diverging
      Mixed
    } derive(Eq, 
    Debug    )

    Values of the pinned XSD type tGatewayDirection.

    GatewayDirection::equal

    source

    GatewayDirection::not_equal

    source
    fn GatewayDirection::not_equal(x : GatewayDirection, y : GatewayDirection) -> Bool

    GatewayDirection::parse

    source
    fn GatewayDirection::parse(token : String) -> GatewayDirection?

    GatewayDirection::to_repr

    source

    GatewayDirection::token

    source
    fn GatewayDirection::token(self : GatewayDirection) -> String

    GlobalBusinessRuleTask

    source
    pub struct GlobalBusinessRuleTask {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tGlobalBusinessRuleTask.

    GlobalBusinessRuleTask::documentation

    source
    fn GlobalBusinessRuleTask::documentation(self : GlobalBusinessRuleTask) -> Field[ReadOnlyArray[Documentation]]

    GlobalBusinessRuleTask::equal

    source

    GlobalBusinessRuleTask::extension_elements

    source

    GlobalBusinessRuleTask::from_element

    source
    fn GlobalBusinessRuleTask::from_element(element : Element) -> GlobalBusinessRuleTask?

    GlobalBusinessRuleTask::id

    source

    GlobalBusinessRuleTask::implementation

    source

    GlobalBusinessRuleTask::io_binding

    source
    fn GlobalBusinessRuleTask::io_binding(self : GlobalBusinessRuleTask) -> Field[ReadOnlyArray[InputOutputBinding]]

    GlobalBusinessRuleTask::io_specification

    source

    GlobalBusinessRuleTask::name

    source

    GlobalBusinessRuleTask::new

    source
    fn GlobalBusinessRuleTask::new(id? : String, name? : String, implementation? : Implementation, contents? : ArrayView[Content]) -> GlobalBusinessRuleTask

    GlobalBusinessRuleTask::not_equal

    source

    GlobalBusinessRuleTask::resource_role

    source
    fn GlobalBusinessRuleTask::resource_role(self : GlobalBusinessRuleTask) -> Field[ReadOnlyArray[ResourceRole]]

    GlobalBusinessRuleTask::supported_interface_ref

    source
    fn GlobalBusinessRuleTask::supported_interface_ref(self : GlobalBusinessRuleTask) -> Field[ReadOnlyArray[Reference]]

    GlobalBusinessRuleTask::to_repr

    source

    GlobalChoreographyTask

    source
    pub struct GlobalChoreographyTask {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tGlobalChoreographyTask.

    GlobalChoreographyTask::artifact

    source
    fn GlobalChoreographyTask::artifact(self : GlobalChoreographyTask) -> Field[ReadOnlyArray[Artifact]]

    GlobalChoreographyTask::choreography_ref

    source
    fn GlobalChoreographyTask::choreography_ref(self : GlobalChoreographyTask) -> Field[ReadOnlyArray[Reference]]

    GlobalChoreographyTask::conversation_association

    source
    fn GlobalChoreographyTask::conversation_association(self : GlobalChoreographyTask) -> Field[ReadOnlyArray[ConversationAssociation]]

    fn GlobalChoreographyTask::conversation_link(self : GlobalChoreographyTask) -> Field[ReadOnlyArray[ConversationLink]]

    GlobalChoreographyTask::conversation_node

    source
    fn GlobalChoreographyTask::conversation_node(self : GlobalChoreographyTask) -> Field[ReadOnlyArray[ConversationNode]]

    GlobalChoreographyTask::correlation_key

    source
    fn GlobalChoreographyTask::correlation_key(self : GlobalChoreographyTask) -> Field[ReadOnlyArray[CorrelationKey]]

    GlobalChoreographyTask::documentation

    source
    fn GlobalChoreographyTask::documentation(self : GlobalChoreographyTask) -> Field[ReadOnlyArray[Documentation]]

    GlobalChoreographyTask::equal

    source

    GlobalChoreographyTask::extension_elements

    source

    GlobalChoreographyTask::flow_element

    source
    fn GlobalChoreographyTask::flow_element(self : GlobalChoreographyTask) -> Field[ReadOnlyArray[FlowElement]]

    GlobalChoreographyTask::from_element

    source
    fn GlobalChoreographyTask::from_element(element : Element) -> GlobalChoreographyTask?

    GlobalChoreographyTask::id

    source

    GlobalChoreographyTask::initiating_participant_ref

    source
    fn GlobalChoreographyTask::initiating_participant_ref(self : GlobalChoreographyTask) -> Field[Reference]

    GlobalChoreographyTask::is_closed

    source
    fn GlobalChoreographyTask::is_closed(self : GlobalChoreographyTask) -> Field[Bool]

    GlobalChoreographyTask::message_flow

    source
    fn GlobalChoreographyTask::message_flow(self : GlobalChoreographyTask) -> Field[ReadOnlyArray[MessageFlow]]

    GlobalChoreographyTask::message_flow_association

    source
    fn GlobalChoreographyTask::message_flow_association(self : GlobalChoreographyTask) -> Field[ReadOnlyArray[MessageFlowAssociation]]

    GlobalChoreographyTask::name

    source

    GlobalChoreographyTask::new

    source
    fn GlobalChoreographyTask::new(id? : String, name? : String, is_closed? : Bool, initiating_participant_ref? : Reference, contents? : ArrayView[Content]) -> GlobalChoreographyTask

    GlobalChoreographyTask::not_equal

    source

    GlobalChoreographyTask::participant

    source
    fn GlobalChoreographyTask::participant(self : GlobalChoreographyTask) -> Field[ReadOnlyArray[Participant]]

    GlobalChoreographyTask::participant_association

    source
    fn GlobalChoreographyTask::participant_association(self : GlobalChoreographyTask) -> Field[ReadOnlyArray[ParticipantAssociation]]

    GlobalChoreographyTask::to_repr

    source

    GlobalConversation

    source
    pub struct GlobalConversation {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tGlobalConversation.

    GlobalConversation::artifact

    source
    fn GlobalConversation::artifact(self : GlobalConversation) -> Field[ReadOnlyArray[Artifact]]

    GlobalConversation::choreography_ref

    source
    fn GlobalConversation::choreography_ref(self : GlobalConversation) -> Field[ReadOnlyArray[Reference]]

    GlobalConversation::conversation_association

    source
    fn GlobalConversation::conversation_association(self : GlobalConversation) -> Field[ReadOnlyArray[ConversationAssociation]]

    fn GlobalConversation::conversation_link(self : GlobalConversation) -> Field[ReadOnlyArray[ConversationLink]]

    GlobalConversation::conversation_node

    source
    fn GlobalConversation::conversation_node(self : GlobalConversation) -> Field[ReadOnlyArray[ConversationNode]]

    GlobalConversation::correlation_key

    source
    fn GlobalConversation::correlation_key(self : GlobalConversation) -> Field[ReadOnlyArray[CorrelationKey]]

    GlobalConversation::documentation

    source
    fn GlobalConversation::documentation(self : GlobalConversation) -> Field[ReadOnlyArray[Documentation]]

    GlobalConversation::equal

    source

    GlobalConversation::extension_elements

    source

    GlobalConversation::from_element

    source
    fn GlobalConversation::from_element(element : Element) -> GlobalConversation?

    GlobalConversation::id

    source
    fn GlobalConversation::id(self : GlobalConversation) -> Field[String]

    GlobalConversation::is_closed

    source
    fn GlobalConversation::is_closed(self : GlobalConversation) -> Field[Bool]

    GlobalConversation::message_flow

    source
    fn GlobalConversation::message_flow(self : GlobalConversation) -> Field[ReadOnlyArray[MessageFlow]]

    GlobalConversation::message_flow_association

    source
    fn GlobalConversation::message_flow_association(self : GlobalConversation) -> Field[ReadOnlyArray[MessageFlowAssociation]]

    GlobalConversation::name

    source
    fn GlobalConversation::name(self : GlobalConversation) -> Field[String]

    GlobalConversation::new

    source
    fn GlobalConversation::new(id? : String, name? : String, is_closed? : Bool, contents? : ArrayView[Content]) -> GlobalConversation

    GlobalConversation::not_equal

    source

    GlobalConversation::participant

    source
    fn GlobalConversation::participant(self : GlobalConversation) -> Field[ReadOnlyArray[Participant]]

    GlobalConversation::participant_association

    source
    fn GlobalConversation::participant_association(self : GlobalConversation) -> Field[ReadOnlyArray[ParticipantAssociation]]

    GlobalConversation::to_repr

    source

    GlobalManualTask

    source
    pub struct GlobalManualTask {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tGlobalManualTask.

    GlobalManualTask::documentation

    source
    fn GlobalManualTask::documentation(self : GlobalManualTask) -> Field[ReadOnlyArray[Documentation]]

    GlobalManualTask::equal

    source

    GlobalManualTask::extension_elements

    source
    fn GlobalManualTask::extension_elements(self : GlobalManualTask) -> Field[ExtensionElements]

    GlobalManualTask::from_element

    source
    fn GlobalManualTask::from_element(element : Element) -> GlobalManualTask?

    GlobalManualTask::id

    source
    fn GlobalManualTask::id(self : GlobalManualTask) -> Field[String]

    GlobalManualTask::io_binding

    source
    fn GlobalManualTask::io_binding(self : GlobalManualTask) -> Field[ReadOnlyArray[InputOutputBinding]]

    GlobalManualTask::io_specification

    source

    GlobalManualTask::name

    source
    fn GlobalManualTask::name(self : GlobalManualTask) -> Field[String]

    GlobalManualTask::new

    source
    fn GlobalManualTask::new(id? : String, name? : String, contents? : ArrayView[Content]) -> GlobalManualTask

    GlobalManualTask::not_equal

    source
    fn GlobalManualTask::not_equal(x : GlobalManualTask, y : GlobalManualTask) -> Bool

    GlobalManualTask::resource_role

    source
    fn GlobalManualTask::resource_role(self : GlobalManualTask) -> Field[ReadOnlyArray[ResourceRole]]

    GlobalManualTask::supported_interface_ref

    source
    fn GlobalManualTask::supported_interface_ref(self : GlobalManualTask) -> Field[ReadOnlyArray[Reference]]

    GlobalManualTask::to_repr

    source

    GlobalScriptTask

    source
    pub struct GlobalScriptTask {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tGlobalScriptTask.

    GlobalScriptTask::documentation

    source
    fn GlobalScriptTask::documentation(self : GlobalScriptTask) -> Field[ReadOnlyArray[Documentation]]

    GlobalScriptTask::equal

    source

    GlobalScriptTask::extension_elements

    source
    fn GlobalScriptTask::extension_elements(self : GlobalScriptTask) -> Field[ExtensionElements]

    GlobalScriptTask::from_element

    source
    fn GlobalScriptTask::from_element(element : Element) -> GlobalScriptTask?

    GlobalScriptTask::id

    source
    fn GlobalScriptTask::id(self : GlobalScriptTask) -> Field[String]

    GlobalScriptTask::io_binding

    source
    fn GlobalScriptTask::io_binding(self : GlobalScriptTask) -> Field[ReadOnlyArray[InputOutputBinding]]

    GlobalScriptTask::io_specification

    source

    GlobalScriptTask::name

    source
    fn GlobalScriptTask::name(self : GlobalScriptTask) -> Field[String]

    GlobalScriptTask::new

    source
    fn GlobalScriptTask::new(id? : String, name? : String, script_language? : String, contents? : ArrayView[Content]) -> GlobalScriptTask

    GlobalScriptTask::not_equal

    source
    fn GlobalScriptTask::not_equal(x : GlobalScriptTask, y : GlobalScriptTask) -> Bool

    GlobalScriptTask::resource_role

    source
    fn GlobalScriptTask::resource_role(self : GlobalScriptTask) -> Field[ReadOnlyArray[ResourceRole]]

    GlobalScriptTask::script

    source

    GlobalScriptTask::script_language

    source
    fn GlobalScriptTask::script_language(self : GlobalScriptTask) -> Field[String]

    GlobalScriptTask::supported_interface_ref

    source
    fn GlobalScriptTask::supported_interface_ref(self : GlobalScriptTask) -> Field[ReadOnlyArray[Reference]]

    GlobalScriptTask::to_repr

    source

    GlobalTask

    source
    pub struct GlobalTask {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tGlobalTask.

    GlobalTask::documentation

    source
    fn GlobalTask::documentation(self : GlobalTask) -> Field[ReadOnlyArray[Documentation]]

    GlobalTask::equal

    source
    fn GlobalTask::equal(GlobalTask, GlobalTask) -> Bool

    GlobalTask::extension_elements

    source
    fn GlobalTask::extension_elements(self : GlobalTask) -> Field[ExtensionElements]

    GlobalTask::from_element

    source
    fn GlobalTask::from_element(element : Element) -> GlobalTask?

    GlobalTask::id

    source
    fn GlobalTask::id(self : GlobalTask) -> Field[String]

    GlobalTask::io_binding

    source
    fn GlobalTask::io_binding(self : GlobalTask) -> Field[ReadOnlyArray[InputOutputBinding]]

    GlobalTask::io_specification

    source
    fn GlobalTask::io_specification(self : GlobalTask) -> Field[InputOutputSpecification]

    GlobalTask::name

    source
    fn GlobalTask::name(self : GlobalTask) -> Field[String]

    GlobalTask::new

    source
    fn GlobalTask::new(id? : String, name? : String, contents? : ArrayView[Content]) -> GlobalTask

    GlobalTask::not_equal

    source
    fn GlobalTask::not_equal(x : GlobalTask, y : GlobalTask) -> Bool

    GlobalTask::resource_role

    source
    fn GlobalTask::resource_role(self : GlobalTask) -> Field[ReadOnlyArray[ResourceRole]]

    GlobalTask::supported_interface_ref

    source
    fn GlobalTask::supported_interface_ref(self : GlobalTask) -> Field[ReadOnlyArray[Reference]]

    GlobalTask::to_repr

    source

    GlobalUserTask

    source
    pub struct GlobalUserTask {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tGlobalUserTask.

    GlobalUserTask::documentation

    source
    fn GlobalUserTask::documentation(self : GlobalUserTask) -> Field[ReadOnlyArray[Documentation]]

    GlobalUserTask::equal

    source

    GlobalUserTask::extension_elements

    source
    fn GlobalUserTask::extension_elements(self : GlobalUserTask) -> Field[ExtensionElements]

    GlobalUserTask::from_element

    source
    fn GlobalUserTask::from_element(element : Element) -> GlobalUserTask?

    GlobalUserTask::id

    source
    fn GlobalUserTask::id(self : GlobalUserTask) -> Field[String]

    GlobalUserTask::implementation

    source
    fn GlobalUserTask::implementation(self : GlobalUserTask) -> Field[Implementation]

    GlobalUserTask::io_binding

    source
    fn GlobalUserTask::io_binding(self : GlobalUserTask) -> Field[ReadOnlyArray[InputOutputBinding]]

    GlobalUserTask::io_specification

    source

    GlobalUserTask::name

    source
    fn GlobalUserTask::name(self : GlobalUserTask) -> Field[String]

    GlobalUserTask::new

    source
    fn GlobalUserTask::new(id? : String, name? : String, implementation? : Implementation, contents? : ArrayView[Content]) -> GlobalUserTask

    GlobalUserTask::not_equal

    source
    fn GlobalUserTask::not_equal(x : GlobalUserTask, y : GlobalUserTask) -> Bool

    GlobalUserTask::rendering

    source
    fn GlobalUserTask::rendering(self : GlobalUserTask) -> Field[ReadOnlyArray[Rendering]]

    GlobalUserTask::resource_role

    source
    fn GlobalUserTask::resource_role(self : GlobalUserTask) -> Field[ReadOnlyArray[ResourceRole]]

    GlobalUserTask::supported_interface_ref

    source
    fn GlobalUserTask::supported_interface_ref(self : GlobalUserTask) -> Field[ReadOnlyArray[Reference]]

    GlobalUserTask::to_repr

    source

    GraphBuildResult

    source
    pub struct GraphBuildResult {
      graph : DocumentGraph?
      diagnostics : ReadOnlyArray[Diagnostic]
    } derive(
    Debug    )

    GraphDirection

    source
    pub(all) enum GraphDirection {
      Forward
      Reverse
      Both
    } derive(Eq, 
    Debug    )

    GraphDirection::equal

    source

    GraphDirection::not_equal

    source
    fn GraphDirection::not_equal(x : GraphDirection, y : GraphDirection) -> Bool

    GraphDirection::to_repr

    source

    GraphEdge

    source
    pub struct GraphEdge {
      kind : GraphEdgeKind
      source : GraphNode
      target : GraphNode
      connection : NodeRef?
    } derive(Eq, 
    Debug    )

    GraphEdge::equal

    source
    fn GraphEdge::equal(GraphEdge, GraphEdge) -> Bool

    GraphEdge::not_equal

    source
    fn GraphEdge::not_equal(x : GraphEdge, y : GraphEdge) -> Bool

    GraphEdge::to_repr

    source

    GraphEdgeKind

    source
    pub(all) enum GraphEdgeKind {
      Containment
      SequenceFlow
      MessageFlow
      Association
      DataAssociation
      ConversationLink
      Reference
    } derive(Eq, 
    Debug    )

    GraphEdgeKind::equal

    source

    GraphEdgeKind::not_equal

    source
    fn GraphEdgeKind::not_equal(x : GraphEdgeKind, y : GraphEdgeKind) -> Bool

    GraphEdgeKind::to_repr

    source

    GraphEndpoint

    source
    pub(all) enum GraphEndpoint {
      Node(NodeHandle)
      Id(String)
      Qualified(ExpandedName)
      Symbol(ResolvedSymbol)
    } derive(Eq, 
    Debug    )

    GraphEndpoint::equal

    source

    GraphEndpoint::not_equal

    source
    fn GraphEndpoint::not_equal(x : GraphEndpoint, y : GraphEndpoint) -> Bool

    GraphEndpoint::to_repr

    source

    GraphFailure

    source
    pub(all) enum GraphFailure {
      InvalidEndpoint
      DocumentMismatch
      InvalidReference(NodeHandle)
      Ambiguous(ReadOnlyArray[GraphNode])
      Limit(GraphLimit)
      InvalidLimits
    } derive(Eq, 
    Debug    )

    GraphFailure::equal

    source

    GraphFailure::not_equal

    source
    fn GraphFailure::not_equal(x : GraphFailure, y : GraphFailure) -> Bool

    GraphFailure::to_repr

    source

    GraphLimit

    source
    pub(all) enum GraphLimit {
      Nodes
      Edges
      Results
      Work
    } derive(Eq, 
    Debug    )

    GraphLimit::equal

    source
    fn GraphLimit::equal(GraphLimit, GraphLimit) -> Bool

    GraphLimit::not_equal

    source
    fn GraphLimit::not_equal(x : GraphLimit, y : GraphLimit) -> Bool

    GraphLimit::to_repr

    source

    GraphLimits

    source
    pub struct GraphLimits {
      nodes : Int
      edges : Int
      results : Int
      work : Int
    } derive(Eq, 
    Debug    )

    GraphLimits::equal

    source
    fn GraphLimits::equal(GraphLimits, GraphLimits) -> Bool

    GraphLimits::new

    source
    fn GraphLimits::new(nodes? : Int, edges? : Int, results? : Int, work? : Int) -> GraphLimits

    GraphLimits::not_equal

    source
    fn GraphLimits::not_equal(x : GraphLimits, y : GraphLimits) -> Bool

    GraphLimits::to_repr

    source

    GraphNode

    source
    pub(all) enum GraphNode {
      Document(NodeRef)
      External(ExternalNode)
    } derive(Eq, 
    Debug    )

    GraphNode::equal

    source
    fn GraphNode::equal(GraphNode, GraphNode) -> Bool

    GraphNode::id

    source
    fn GraphNode::id(self : GraphNode) -> String?

    GraphNode::not_equal

    source
    fn GraphNode::not_equal(x : GraphNode, y : GraphNode) -> Bool

    GraphNode::to_repr

    source

    GraphRoute

    source
    pub struct GraphRoute {
      nodes : ReadOnlyArray[GraphNode]
      edges : ReadOnlyArray[GraphEdge]
    } derive(Eq, 
    Debug    )

    GraphRoute::equal

    source
    fn GraphRoute::equal(GraphRoute, GraphRoute) -> Bool

    GraphRoute::not_equal

    source
    fn GraphRoute::not_equal(x : GraphRoute, y : GraphRoute) -> Bool

    GraphRoute::to_repr

    source

    Group

    source
    pub struct Group {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tGroup.

    Group::category_value_ref

    source
    fn Group::category_value_ref(self : Group) -> Field[Reference]

    Group::documentation

    source
    fn Group::documentation(self : Group) -> Field[ReadOnlyArray[Documentation]]

    Group::equal

    source
    fn Group::equal(Group, Group) -> Bool

    Group::extension_elements

    source
    fn Group::extension_elements(self : Group) -> Field[ExtensionElements]

    Group::from_element

    source
    fn Group::from_element(element : Element) -> Group?

    Group::id

    source
    fn Group::id(self : Group) -> Field[String]

    Group::new

    source
    fn Group::new(id? : String, category_value_ref? : Reference, contents? : ArrayView[Content]) -> Group

    Group::not_equal

    source
    fn Group::not_equal(x : Group, y : Group) -> Bool

    Group::to_repr

    source

    HumanPerformer

    source
    pub struct HumanPerformer {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tHumanPerformer.

    HumanPerformer::documentation

    source
    fn HumanPerformer::documentation(self : HumanPerformer) -> Field[ReadOnlyArray[Documentation]]

    HumanPerformer::equal

    source

    HumanPerformer::extension_elements

    source
    fn HumanPerformer::extension_elements(self : HumanPerformer) -> Field[ExtensionElements]

    HumanPerformer::from_element

    source
    fn HumanPerformer::from_element(element : Element) -> HumanPerformer?

    HumanPerformer::id

    source
    fn HumanPerformer::id(self : HumanPerformer) -> Field[String]

    HumanPerformer::name

    source
    fn HumanPerformer::name(self : HumanPerformer) -> Field[String]

    HumanPerformer::new

    source
    fn HumanPerformer::new(id? : String, name? : String, contents? : ArrayView[Content]) -> HumanPerformer

    HumanPerformer::not_equal

    source
    fn HumanPerformer::not_equal(x : HumanPerformer, y : HumanPerformer) -> Bool

    HumanPerformer::resource_assignment_expression

    source
    fn HumanPerformer::resource_assignment_expression(self : HumanPerformer) -> Field[ResourceAssignmentExpression]

    HumanPerformer::resource_parameter_binding

    source
    fn HumanPerformer::resource_parameter_binding(self : HumanPerformer) -> Field[ReadOnlyArray[ResourceParameterBinding]]

    HumanPerformer::resource_ref

    source
    fn HumanPerformer::resource_ref(self : HumanPerformer) -> Field[Reference]

    HumanPerformer::to_repr

    source

    IdLookup

    source
    pub(all) enum IdLookup {
      Found(IndexedElement)
      Ambiguous(ReadOnlyArray[IndexedElement])
      Missing
      Incomplete
    } derive(Eq, 
    Debug    )

    IdLookup::equal

    source
    fn IdLookup::equal(IdLookup, IdLookup) -> Bool

    IdLookup::not_equal

    source
    fn IdLookup::not_equal(x : IdLookup, y : IdLookup) -> Bool

    IdLookup::to_repr

    source

    Implementation

    source
    pub(all) enum Implementation {
      Unspecified
      WebService
      Uri(String)
    } derive(Eq, 
    Debug    )

    Values of the pinned XSD type tImplementation.

    Implementation::equal

    source

    Implementation::not_equal

    source
    fn Implementation::not_equal(x : Implementation, y : Implementation) -> Bool

    Implementation::parse

    source
    fn Implementation::parse(token : String) -> Implementation?

    Implementation::to_repr

    source

    Implementation::token

    source
    fn Implementation::token(self : Implementation) -> String

    ImplicitThrowEvent

    source
    pub struct ImplicitThrowEvent {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tImplicitThrowEvent.

    ImplicitThrowEvent::auditing

    source

    ImplicitThrowEvent::category_value_ref

    source
    fn ImplicitThrowEvent::category_value_ref(self : ImplicitThrowEvent) -> Field[ReadOnlyArray[Reference]]

    ImplicitThrowEvent::data_input

    source
    fn ImplicitThrowEvent::data_input(self : ImplicitThrowEvent) -> Field[ReadOnlyArray[DataInput]]

    ImplicitThrowEvent::data_input_association

    source
    fn ImplicitThrowEvent::data_input_association(self : ImplicitThrowEvent) -> Field[ReadOnlyArray[DataInputAssociation]]

    ImplicitThrowEvent::documentation

    source
    fn ImplicitThrowEvent::documentation(self : ImplicitThrowEvent) -> Field[ReadOnlyArray[Documentation]]

    ImplicitThrowEvent::equal

    source

    ImplicitThrowEvent::event_definition

    source
    fn ImplicitThrowEvent::event_definition(self : ImplicitThrowEvent) -> Field[ReadOnlyArray[EventDefinition]]

    ImplicitThrowEvent::event_definition_ref

    source
    fn ImplicitThrowEvent::event_definition_ref(self : ImplicitThrowEvent) -> Field[ReadOnlyArray[Reference]]

    ImplicitThrowEvent::extension_elements

    source

    ImplicitThrowEvent::from_element

    source
    fn ImplicitThrowEvent::from_element(element : Element) -> ImplicitThrowEvent?

    ImplicitThrowEvent::id

    source
    fn ImplicitThrowEvent::id(self : ImplicitThrowEvent) -> Field[String]

    ImplicitThrowEvent::incoming

    source
    fn ImplicitThrowEvent::incoming(self : ImplicitThrowEvent) -> Field[ReadOnlyArray[Reference]]

    ImplicitThrowEvent::input_set

    source

    ImplicitThrowEvent::monitoring

    source

    ImplicitThrowEvent::name

    source
    fn ImplicitThrowEvent::name(self : ImplicitThrowEvent) -> Field[String]

    ImplicitThrowEvent::new

    source
    fn ImplicitThrowEvent::new(id? : String, name? : String, contents? : ArrayView[Content]) -> ImplicitThrowEvent

    ImplicitThrowEvent::not_equal

    source

    ImplicitThrowEvent::outgoing

    source
    fn ImplicitThrowEvent::outgoing(self : ImplicitThrowEvent) -> Field[ReadOnlyArray[Reference]]

    ImplicitThrowEvent::property

    source
    fn ImplicitThrowEvent::property(self : ImplicitThrowEvent) -> Field[ReadOnlyArray[Property]]

    ImplicitThrowEvent::to_repr

    source

    Import

    source
    pub struct Import {
      element : Element
    } derive(Eq, 
    Debug    )

    Import::equal

    source
    fn Import::equal(Import, Import) -> Bool

    Import::from_element

    source
    fn Import::from_element(element : Element) -> Import?

    Import::import_type

    source
    fn Import::import_type(self : Import) -> Field[String]

    Import::location

    source
    fn Import::location(self : Import) -> Field[String]

    Import::namespace_uri

    source
    fn Import::namespace_uri(self : Import) -> Field[String]

    Import::new

    source
    fn Import::new(namespace_uri : String, location : String, import_type : String) -> Import

    Import::not_equal

    source
    fn Import::not_equal(x : Import, y : Import) -> Bool

    Import::to_repr

    source

    InclusiveGateway

    source
    pub struct InclusiveGateway {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tInclusiveGateway.

    InclusiveGateway::auditing

    source

    InclusiveGateway::category_value_ref

    source
    fn InclusiveGateway::category_value_ref(self : InclusiveGateway) -> Field[ReadOnlyArray[Reference]]

    InclusiveGateway::default_

    source

    InclusiveGateway::documentation

    source
    fn InclusiveGateway::documentation(self : InclusiveGateway) -> Field[ReadOnlyArray[Documentation]]

    InclusiveGateway::equal

    source

    InclusiveGateway::extension_elements

    source
    fn InclusiveGateway::extension_elements(self : InclusiveGateway) -> Field[ExtensionElements]

    InclusiveGateway::from_element

    source
    fn InclusiveGateway::from_element(element : Element) -> InclusiveGateway?

    InclusiveGateway::gateway_direction

    source
    fn InclusiveGateway::gateway_direction(self : InclusiveGateway) -> Field[GatewayDirection]

    InclusiveGateway::id

    source
    fn InclusiveGateway::id(self : InclusiveGateway) -> Field[String]

    InclusiveGateway::incoming

    source
    fn InclusiveGateway::incoming(self : InclusiveGateway) -> Field[ReadOnlyArray[Reference]]

    InclusiveGateway::monitoring

    source

    InclusiveGateway::name

    source
    fn InclusiveGateway::name(self : InclusiveGateway) -> Field[String]

    InclusiveGateway::new

    source
    fn InclusiveGateway::new(id? : String, name? : String, gateway_direction? : GatewayDirection, default_? : Reference, contents? : ArrayView[Content]) -> InclusiveGateway

    InclusiveGateway::not_equal

    source
    fn InclusiveGateway::not_equal(x : InclusiveGateway, y : InclusiveGateway) -> Bool

    InclusiveGateway::outgoing

    source
    fn InclusiveGateway::outgoing(self : InclusiveGateway) -> Field[ReadOnlyArray[Reference]]

    InclusiveGateway::to_repr

    source

    IndexedElement

    source
    pub struct IndexedElement {
      ordinal : Int
      element : Element
      parent : Int?
      child_index : Int
      children : ReadOnlyArray[Int]
      depth : Int
      scope : Int?
      payload : Bool
    } derive(Eq, 
    Debug    )

    IndexedElement::equal

    source

    IndexedElement::not_equal

    source
    fn IndexedElement::not_equal(x : IndexedElement, y : IndexedElement) -> Bool

    IndexedElement::to_repr

    source

    IndexedResource

    source
    pub struct IndexedResource {
      resource_id : String?
      index : DocumentIndex
      records : Int
    } derive(
    Debug    )

    One immutable document index in the resolver's explicit import closure. records counts the bounded element/attribute/content/namespace work, not only elements. Hosts can reuse an index without fetching or reparsing XML.

    IndexedResource::to_repr

    source

    InputOutputBinding

    source
    pub struct InputOutputBinding {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tInputOutputBinding.

    InputOutputBinding::documentation

    source
    fn InputOutputBinding::documentation(self : InputOutputBinding) -> Field[ReadOnlyArray[Documentation]]

    InputOutputBinding::equal

    source

    InputOutputBinding::extension_elements

    source

    InputOutputBinding::from_element

    source
    fn InputOutputBinding::from_element(element : Element) -> InputOutputBinding?

    InputOutputBinding::id

    source
    fn InputOutputBinding::id(self : InputOutputBinding) -> Field[String]

    InputOutputBinding::input_data_ref

    source
    fn InputOutputBinding::input_data_ref(self : InputOutputBinding) -> Field[Reference]

    InputOutputBinding::new

    source
    fn InputOutputBinding::new(id? : String, operation_ref? : Reference, input_data_ref? : Reference, output_data_ref? : Reference, contents? : ArrayView[Content]) -> InputOutputBinding

    InputOutputBinding::not_equal

    source

    InputOutputBinding::operation_ref

    source

    InputOutputBinding::output_data_ref

    source
    fn InputOutputBinding::output_data_ref(self : InputOutputBinding) -> Field[Reference]

    InputOutputBinding::to_repr

    source

    InputOutputSpecification

    source
    pub struct InputOutputSpecification {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tInputOutputSpecification.

    InputOutputSpecification::data_input

    source
    fn InputOutputSpecification::data_input(self : InputOutputSpecification) -> Field[ReadOnlyArray[DataInput]]

    InputOutputSpecification::data_output

    source
    fn InputOutputSpecification::data_output(self : InputOutputSpecification) -> Field[ReadOnlyArray[DataOutput]]

    InputOutputSpecification::documentation

    source
    fn InputOutputSpecification::documentation(self : InputOutputSpecification) -> Field[ReadOnlyArray[Documentation]]

    InputOutputSpecification::equal

    source

    InputOutputSpecification::extension_elements

    source

    InputOutputSpecification::from_element

    source

    InputOutputSpecification::id

    source

    InputOutputSpecification::input_set

    source
    fn InputOutputSpecification::input_set(self : InputOutputSpecification) -> Field[ReadOnlyArray[InputSet]]

    InputOutputSpecification::new

    source

    InputOutputSpecification::not_equal

    source

    InputOutputSpecification::output_set

    source
    fn InputOutputSpecification::output_set(self : InputOutputSpecification) -> Field[ReadOnlyArray[OutputSet]]

    InputOutputSpecification::to_repr

    source

    InputSet

    source
    pub struct InputSet {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tInputSet.

    InputSet::data_input_refs

    source
    fn InputSet::data_input_refs(self : InputSet) -> Field[ReadOnlyArray[Reference]]

    InputSet::documentation

    source
    fn InputSet::documentation(self : InputSet) -> Field[ReadOnlyArray[Documentation]]

    InputSet::equal

    source
    fn InputSet::equal(InputSet, InputSet) -> Bool

    InputSet::extension_elements

    source
    fn InputSet::extension_elements(self : InputSet) -> Field[ExtensionElements]

    InputSet::from_element

    source
    fn InputSet::from_element(element : Element) -> InputSet?

    InputSet::id

    source
    fn InputSet::id(self : InputSet) -> Field[String]

    InputSet::name

    source
    fn InputSet::name(self : InputSet) -> Field[String]

    InputSet::new

    source
    fn InputSet::new(id? : String, name? : String, contents? : ArrayView[Content]) -> InputSet

    InputSet::not_equal

    source
    fn InputSet::not_equal(x : InputSet, y : InputSet) -> Bool

    InputSet::optional_input_refs

    source
    fn InputSet::optional_input_refs(self : InputSet) -> Field[ReadOnlyArray[Reference]]

    InputSet::output_set_refs

    source
    fn InputSet::output_set_refs(self : InputSet) -> Field[ReadOnlyArray[Reference]]

    InputSet::to_repr

    source

    InputSet::while_executing_input_refs

    source
    fn InputSet::while_executing_input_refs(self : InputSet) -> Field[ReadOnlyArray[Reference]]

    Interface

    source
    pub struct Interface {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tInterface.

    Interface::documentation

    source
    fn Interface::documentation(self : Interface) -> Field[ReadOnlyArray[Documentation]]

    Interface::equal

    source
    fn Interface::equal(Interface, Interface) -> Bool

    Interface::extension_elements

    source
    fn Interface::extension_elements(self : Interface) -> Field[ExtensionElements]

    Interface::from_element

    source
    fn Interface::from_element(element : Element) -> Interface?

    Interface::id

    source
    fn Interface::id(self : Interface) -> Field[String]

    Interface::implementation_ref

    source
    fn Interface::implementation_ref(self : Interface) -> Field[Reference]

    Interface::name

    source
    fn Interface::name(self : Interface) -> Field[String]

    Interface::new

    source
    fn Interface::new(id? : String, name? : String, implementation_ref? : Reference, contents? : ArrayView[Content]) -> Interface

    Interface::not_equal

    source
    fn Interface::not_equal(x : Interface, y : Interface) -> Bool

    Interface::operation

    source
    fn Interface::operation(self : Interface) -> Field[ReadOnlyArray[Operation]]

    Interface::to_repr

    source

    IntermediateCatchEvent

    source
    pub struct IntermediateCatchEvent {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tIntermediateCatchEvent.

    IntermediateCatchEvent::auditing

    source

    IntermediateCatchEvent::category_value_ref

    source
    fn IntermediateCatchEvent::category_value_ref(self : IntermediateCatchEvent) -> Field[ReadOnlyArray[Reference]]

    IntermediateCatchEvent::data_output

    source
    fn IntermediateCatchEvent::data_output(self : IntermediateCatchEvent) -> Field[ReadOnlyArray[DataOutput]]

    IntermediateCatchEvent::data_output_association

    source
    fn IntermediateCatchEvent::data_output_association(self : IntermediateCatchEvent) -> Field[ReadOnlyArray[DataOutputAssociation]]

    IntermediateCatchEvent::documentation

    source
    fn IntermediateCatchEvent::documentation(self : IntermediateCatchEvent) -> Field[ReadOnlyArray[Documentation]]

    IntermediateCatchEvent::equal

    source

    IntermediateCatchEvent::event_definition

    source
    fn IntermediateCatchEvent::event_definition(self : IntermediateCatchEvent) -> Field[ReadOnlyArray[EventDefinition]]

    IntermediateCatchEvent::event_definition_ref

    source
    fn IntermediateCatchEvent::event_definition_ref(self : IntermediateCatchEvent) -> Field[ReadOnlyArray[Reference]]

    IntermediateCatchEvent::extension_elements

    source

    IntermediateCatchEvent::from_element

    source
    fn IntermediateCatchEvent::from_element(element : Element) -> IntermediateCatchEvent?

    IntermediateCatchEvent::id

    source

    IntermediateCatchEvent::incoming

    source
    fn IntermediateCatchEvent::incoming(self : IntermediateCatchEvent) -> Field[ReadOnlyArray[Reference]]

    IntermediateCatchEvent::monitoring

    source

    IntermediateCatchEvent::name

    source

    IntermediateCatchEvent::new

    source
    fn IntermediateCatchEvent::new(id? : String, name? : String, parallel_multiple? : Bool, contents? : ArrayView[Content]) -> IntermediateCatchEvent

    IntermediateCatchEvent::not_equal

    source

    IntermediateCatchEvent::outgoing

    source
    fn IntermediateCatchEvent::outgoing(self : IntermediateCatchEvent) -> Field[ReadOnlyArray[Reference]]

    IntermediateCatchEvent::output_set

    source

    IntermediateCatchEvent::parallel_multiple

    source
    fn IntermediateCatchEvent::parallel_multiple(self : IntermediateCatchEvent) -> Field[Bool]

    IntermediateCatchEvent::property

    source
    fn IntermediateCatchEvent::property(self : IntermediateCatchEvent) -> Field[ReadOnlyArray[Property]]

    IntermediateCatchEvent::to_repr

    source

    IntermediateThrowEvent

    source
    pub struct IntermediateThrowEvent {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tIntermediateThrowEvent.

    IntermediateThrowEvent::auditing

    source

    IntermediateThrowEvent::category_value_ref

    source
    fn IntermediateThrowEvent::category_value_ref(self : IntermediateThrowEvent) -> Field[ReadOnlyArray[Reference]]

    IntermediateThrowEvent::data_input

    source
    fn IntermediateThrowEvent::data_input(self : IntermediateThrowEvent) -> Field[ReadOnlyArray[DataInput]]

    IntermediateThrowEvent::data_input_association

    source
    fn IntermediateThrowEvent::data_input_association(self : IntermediateThrowEvent) -> Field[ReadOnlyArray[DataInputAssociation]]

    IntermediateThrowEvent::documentation

    source
    fn IntermediateThrowEvent::documentation(self : IntermediateThrowEvent) -> Field[ReadOnlyArray[Documentation]]

    IntermediateThrowEvent::equal

    source

    IntermediateThrowEvent::event_definition

    source
    fn IntermediateThrowEvent::event_definition(self : IntermediateThrowEvent) -> Field[ReadOnlyArray[EventDefinition]]

    IntermediateThrowEvent::event_definition_ref

    source
    fn IntermediateThrowEvent::event_definition_ref(self : IntermediateThrowEvent) -> Field[ReadOnlyArray[Reference]]

    IntermediateThrowEvent::extension_elements

    source

    IntermediateThrowEvent::from_element

    source
    fn IntermediateThrowEvent::from_element(element : Element) -> IntermediateThrowEvent?

    IntermediateThrowEvent::id

    source

    IntermediateThrowEvent::incoming

    source
    fn IntermediateThrowEvent::incoming(self : IntermediateThrowEvent) -> Field[ReadOnlyArray[Reference]]

    IntermediateThrowEvent::input_set

    source

    IntermediateThrowEvent::monitoring

    source

    IntermediateThrowEvent::name

    source

    IntermediateThrowEvent::new

    source
    fn IntermediateThrowEvent::new(id? : String, name? : String, contents? : ArrayView[Content]) -> IntermediateThrowEvent

    IntermediateThrowEvent::not_equal

    source

    IntermediateThrowEvent::outgoing

    source
    fn IntermediateThrowEvent::outgoing(self : IntermediateThrowEvent) -> Field[ReadOnlyArray[Reference]]

    IntermediateThrowEvent::property

    source
    fn IntermediateThrowEvent::property(self : IntermediateThrowEvent) -> Field[ReadOnlyArray[Property]]

    IntermediateThrowEvent::to_repr

    source

    ItemDefinition

    source
    pub struct ItemDefinition {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tItemDefinition.

    ItemDefinition::documentation

    source
    fn ItemDefinition::documentation(self : ItemDefinition) -> Field[ReadOnlyArray[Documentation]]

    ItemDefinition::equal

    source

    ItemDefinition::extension_elements

    source
    fn ItemDefinition::extension_elements(self : ItemDefinition) -> Field[ExtensionElements]

    ItemDefinition::from_element

    source
    fn ItemDefinition::from_element(element : Element) -> ItemDefinition?

    ItemDefinition::id

    source
    fn ItemDefinition::id(self : ItemDefinition) -> Field[String]

    ItemDefinition::is_collection

    source
    fn ItemDefinition::is_collection(self : ItemDefinition) -> Field[Bool]

    ItemDefinition::item_kind

    source
    fn ItemDefinition::item_kind(self : ItemDefinition) -> Field[ItemKind]

    ItemDefinition::new

    source
    fn ItemDefinition::new(id? : String, structure_ref? : Reference, is_collection? : Bool, item_kind? : ItemKind, contents? : ArrayView[Content]) -> ItemDefinition

    ItemDefinition::not_equal

    source
    fn ItemDefinition::not_equal(x : ItemDefinition, y : ItemDefinition) -> Bool

    ItemDefinition::structure_ref

    source
    fn ItemDefinition::structure_ref(self : ItemDefinition) -> Field[Reference]

    ItemDefinition::to_repr

    source

    ItemKind

    source
    pub(all) enum ItemKind {
      Information
      Physical
    } derive(Eq, 
    Debug    )

    Values of the pinned XSD type tItemKind.

    ItemKind::equal

    source
    fn ItemKind::equal(ItemKind, ItemKind) -> Bool

    ItemKind::not_equal

    source
    fn ItemKind::not_equal(x : ItemKind, y : ItemKind) -> Bool

    ItemKind::parse

    source
    fn ItemKind::parse(token : String) -> ItemKind?

    ItemKind::to_repr

    source

    ItemKind::token

    source
    fn ItemKind::token(self : ItemKind) -> String

    Kind

    source
    pub(all) enum Kind {
      DcFont
      DiEdge
      DiNode
      DcPoint
      DiLabel
      DiPlane
      DiShape
      DiStyle
      Bounds
      To
      DiDiagram
      Waypoint
      From
      Lane
      Task
      Text
      DiExtension
      Edge
      Error
      Event
      Group
      BpmnBPMNLabel
      Plane
      Shape
      Import
      Script
      Signal
      Source
      Target
      DiLabeledEdge
      Gateway
      LaneSet
      Message
      Process
      DiLabeledShape
      Diagram
      Activity
      Artifact
      Auditing
      Category
      DataPath
      EndEvent
      EndPoint
      ErrorRef
      FlowNode
      Incoming
      InputSet
      Outgoing
      Property
      Resource
      SendTask
      Supports
      TimeDate
      UserTask
      Condition
      DataInput
      DataState
      DataStore
      Extension
      Interface
      IoBinding
      Operation
      OutputSet
      Performer
      Rendering
      SourceRef
      TargetRef
      TimeCycle
      DiDiagramElement
      Assignment
      CatchEvent
      DataObject
      DataOutput
      Escalation
      Expression
      GlobalTask
      ManualTask
      Monitoring
      ScriptTask
      StartEvent
      SubProcess
      ThrowEvent
      BpmnBPMNLabelStyle
      Association
      BaseElement
      Definitions
      EndPointRef
      FlowElement
      FlowNodeRef
      MessageFlow
      MessagePath
      Participant
      PartnerRole
      ReceiveTask
      ResourceRef
      RootElement
      ServiceTask
      Transaction
      CallActivity
      ChildLaneSet
      Choreography
      Conversation
      InMessageRef
      InputSetRefs
      InterfaceRef
      OperationRef
      Relationship
      ResourceRole
      SequenceFlow
      TimeDuration
      BoundaryEvent
      CategoryValue
      Collaboration
      DataInputRefs
      Documentation
      InputDataItem
      LoopCondition
      OutMessageRef
      OutputSetRefs
      PartnerEntity
      ComplexGateway
      CorrelationKey
      DataOutputRefs
      GlobalUserTask
      HumanPerformer
      ItemDefinition
      MessageFlowRef
      OutputDataItem
      ParticipantRef
      PotentialOwner
      TextAnnotation
      Transformation
      AdHocSubProcess
      CallableElement
      ChoreographyRef
      DataAssociation
      EventDefinition
      IoSpecification
      LoopCardinality
      ParallelGateway
      SubChoreography
      SubConversation
      BusinessRuleTask
      CallChoreography
      CallConversation
      CategoryValueRef
      ChoreographyTask
      ConversationLink
      ConversationNode
      ExclusiveGateway
      FormalExpression
      GlobalManualTask
      GlobalScriptTask
      InclusiveGateway
      LoopDataInputRef
      PartitionElement
      EventBasedGateway
      ExtensionElements
      LoopDataOutputRef
      OptionalInputRefs
      ResourceParameter
      DataStoreReference
      EventDefinitionRef
      GlobalConversation
      ImplicitThrowEvent
      OptionalOutputRefs
      ActivationCondition
      CompletionCondition
      ConditionExpression
      CorrelationProperty
      DataObjectReference
      InnerParticipantRef
      LinkEventDefinition
      LoopCharacteristics
      OuterParticipantRef
      ChoreographyActivity
      DataInputAssociation
      ErrorEventDefinition
      TimerEventDefinition
      CancelEventDefinition
      DataOutputAssociation
      SignalEventDefinition
      SupportedInterfaceRef
      CorrelationPropertyRef
      GlobalBusinessRuleTask
      GlobalChoreographyTask
      IntermediateCatchEvent
      IntermediateThrowEvent
      MessageEventDefinition
      MessageFlowAssociation
      ParticipantAssociation
      ConversationAssociation
      CorrelationSubscription
      ParticipantMultiplicity
      WhileExecutingInputRefs
      ResourceParameterBinding
      TerminateEventDefinition
      WhileExecutingOutputRefs
      CompensateEventDefinition
      ComplexBehaviorDefinition
      EscalationEventDefinition
      ConditionalEventDefinition
      CorrelationPropertyBinding
      BaseElementWithMixedContent
      StandardLoopCharacteristics
      ResourceAssignmentExpression
      MultiInstanceLoopCharacteristics
      CorrelationPropertyRetrievalExpression
      Foreign(ExpandedName)
      Unknown(ExpandedName)
    } derive(Eq, 
    Debug    )

    Standard element names derived from global and local declarations.

    Kind::declared_type

    source
    fn Kind::declared_type(self : Kind) -> ExpandedName?

    Kind::equal

    source
    fn Kind::equal(Kind, Kind) -> Bool

    Kind::local_name

    source
    fn Kind::local_name(self : Kind) -> String

    Kind::name

    source
    fn Kind::name(self : Kind) -> ExpandedName

    Kind::namespace_uri

    source
    fn Kind::namespace_uri(self : Kind) -> String

    Kind::not_equal

    source
    fn Kind::not_equal(x : Kind, y : Kind) -> Bool

    Kind::substitutes

    source
    fn Kind::substitutes(self : Kind, head : ExpandedName) -> Bool

    Kind::to_repr

    source

    Lane

    source
    pub struct Lane {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tLane.

    Lane::child_lane_set

    source
    fn Lane::child_lane_set(self : Lane) -> Field[LaneSet]

    Lane::documentation

    source
    fn Lane::documentation(self : Lane) -> Field[ReadOnlyArray[Documentation]]

    Lane::equal

    source
    fn Lane::equal(Lane, Lane) -> Bool

    Lane::extension_elements

    source
    fn Lane::extension_elements(self : Lane) -> Field[ExtensionElements]

    Lane::flow_node_ref

    source
    fn Lane::flow_node_ref(self : Lane) -> Field[ReadOnlyArray[Reference]]

    Lane::from_element

    source
    fn Lane::from_element(element : Element) -> Lane?

    Lane::id

    source
    fn Lane::id(self : Lane) -> Field[String]

    Lane::name

    source
    fn Lane::name(self : Lane) -> Field[String]

    Lane::new

    source
    fn Lane::new(id? : String, name? : String, partition_element_ref? : Reference, contents? : ArrayView[Content]) -> Lane

    Lane::not_equal

    source
    fn Lane::not_equal(x : Lane, y : Lane) -> Bool

    Lane::partition_element

    source
    fn Lane::partition_element(self : Lane) -> Field[BaseElement]

    Lane::partition_element_ref

    source
    fn Lane::partition_element_ref(self : Lane) -> Field[Reference]

    Lane::to_repr

    source

    LaneSet

    source
    pub struct LaneSet {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tLaneSet.

    LaneSet::documentation

    source
    fn LaneSet::documentation(self : LaneSet) -> Field[ReadOnlyArray[Documentation]]

    LaneSet::equal

    source
    fn LaneSet::equal(LaneSet, LaneSet) -> Bool

    LaneSet::extension_elements

    source
    fn LaneSet::extension_elements(self : LaneSet) -> Field[ExtensionElements]

    LaneSet::from_element

    source
    fn LaneSet::from_element(element : Element) -> LaneSet?

    LaneSet::id

    source
    fn LaneSet::id(self : LaneSet) -> Field[String]

    LaneSet::lane

    source
    fn LaneSet::lane(self : LaneSet) -> Field[ReadOnlyArray[Lane]]

    LaneSet::name

    source
    fn LaneSet::name(self : LaneSet) -> Field[String]

    LaneSet::new

    source
    fn LaneSet::new(id? : String, name? : String, contents? : ArrayView[Content]) -> LaneSet

    LaneSet::not_equal

    source
    fn LaneSet::not_equal(x : LaneSet, y : LaneSet) -> Bool

    LaneSet::to_repr

    source

    Limits

    source
    pub struct Limits {
      source_units : Int
      output_units : Int
      nodes : Int
      depth : Int
      token_units : Int
      diagnostics : Int
    } derive(Eq, 
    Debug    )

    A processing bound is inclusive. All fields must be positive. Node count includes the document node, elements, content nodes and attributes.

    Limits::equal

    source
    fn Limits::equal(Limits, Limits) -> Bool

    Limits::new

    source
    fn Limits::new(source_units? : Int, output_units? : Int, nodes? : Int, depth? : Int, token_units? : Int, diagnostics? : Int) -> Limits

    Limits::not_equal

    source
    fn Limits::not_equal(x : Limits, y : Limits) -> Bool

    Limits::to_repr

    source

    LinkEventDefinition

    source
    pub struct LinkEventDefinition {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tLinkEventDefinition.

    LinkEventDefinition::documentation

    source
    fn LinkEventDefinition::documentation(self : LinkEventDefinition) -> Field[ReadOnlyArray[Documentation]]

    LinkEventDefinition::equal

    source

    LinkEventDefinition::extension_elements

    source

    LinkEventDefinition::from_element

    source
    fn LinkEventDefinition::from_element(element : Element) -> LinkEventDefinition?

    LinkEventDefinition::id

    source

    LinkEventDefinition::name

    source
    fn LinkEventDefinition::name(self : LinkEventDefinition) -> Field[String]

    LinkEventDefinition::new

    source
    fn LinkEventDefinition::new(id? : String, name? : String, contents? : ArrayView[Content]) -> LinkEventDefinition

    LinkEventDefinition::not_equal

    source

    LinkEventDefinition::source

    source
    fn LinkEventDefinition::source(self : LinkEventDefinition) -> Field[ReadOnlyArray[Reference]]

    LinkEventDefinition::target

    source

    LinkEventDefinition::to_repr

    source

    Location

    source
    pub struct Location {
      source_id : String?
      start : Position
      end : Position
    } derive(Eq, 
    Debug    )

    Location::equal

    source
    fn Location::equal(Location, Location) -> Bool

    Location::not_equal

    source
    fn Location::not_equal(x : Location, y : Location) -> Bool

    Location::to_repr

    source

    LoopCharacteristics

    source
    pub struct LoopCharacteristics {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tLoopCharacteristics.

    LoopCharacteristics::documentation

    source
    fn LoopCharacteristics::documentation(self : LoopCharacteristics) -> Field[ReadOnlyArray[Documentation]]

    LoopCharacteristics::equal

    source

    LoopCharacteristics::extension_elements

    source

    LoopCharacteristics::from_element

    source
    fn LoopCharacteristics::from_element(element : Element) -> LoopCharacteristics?

    LoopCharacteristics::id

    source

    LoopCharacteristics::not_equal

    source

    LoopCharacteristics::to_repr

    source

    ManualTask

    source
    pub struct ManualTask {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tManualTask.

    ManualTask::auditing

    source
    fn ManualTask::auditing(self : ManualTask) -> Field[Auditing]

    ManualTask::category_value_ref

    source
    fn ManualTask::category_value_ref(self : ManualTask) -> Field[ReadOnlyArray[Reference]]

    ManualTask::completion_quantity

    source
    fn ManualTask::completion_quantity(self : ManualTask) -> Field[ExactInteger]

    ManualTask::data_input_association

    source
    fn ManualTask::data_input_association(self : ManualTask) -> Field[ReadOnlyArray[DataInputAssociation]]

    ManualTask::data_output_association

    source
    fn ManualTask::data_output_association(self : ManualTask) -> Field[ReadOnlyArray[DataOutputAssociation]]

    ManualTask::default_

    source
    fn ManualTask::default_(self : ManualTask) -> Field[Reference]

    ManualTask::documentation

    source
    fn ManualTask::documentation(self : ManualTask) -> Field[ReadOnlyArray[Documentation]]

    ManualTask::equal

    source
    fn ManualTask::equal(ManualTask, ManualTask) -> Bool

    ManualTask::extension_elements

    source
    fn ManualTask::extension_elements(self : ManualTask) -> Field[ExtensionElements]

    ManualTask::from_element

    source
    fn ManualTask::from_element(element : Element) -> ManualTask?

    ManualTask::id

    source
    fn ManualTask::id(self : ManualTask) -> Field[String]

    ManualTask::incoming

    source
    fn ManualTask::incoming(self : ManualTask) -> Field[ReadOnlyArray[Reference]]

    ManualTask::io_specification

    source
    fn ManualTask::io_specification(self : ManualTask) -> Field[InputOutputSpecification]

    ManualTask::is_for_compensation

    source
    fn ManualTask::is_for_compensation(self : ManualTask) -> Field[Bool]

    ManualTask::loop_characteristics

    source
    fn ManualTask::loop_characteristics(self : ManualTask) -> Field[LoopCharacteristics]

    ManualTask::monitoring

    source
    fn ManualTask::monitoring(self : ManualTask) -> Field[Monitoring]

    ManualTask::name

    source
    fn ManualTask::name(self : ManualTask) -> Field[String]

    ManualTask::new

    source
    fn ManualTask::new(id? : String, name? : String, is_for_compensation? : Bool, start_quantity? : ExactInteger, completion_quantity? : ExactInteger, default_? : Reference, contents? : ArrayView[Content]) -> ManualTask

    ManualTask::not_equal

    source
    fn ManualTask::not_equal(x : ManualTask, y : ManualTask) -> Bool

    ManualTask::outgoing

    source
    fn ManualTask::outgoing(self : ManualTask) -> Field[ReadOnlyArray[Reference]]

    ManualTask::property

    source
    fn ManualTask::property(self : ManualTask) -> Field[ReadOnlyArray[Property]]

    ManualTask::resource_role

    source
    fn ManualTask::resource_role(self : ManualTask) -> Field[ReadOnlyArray[ResourceRole]]

    ManualTask::start_quantity

    source
    fn ManualTask::start_quantity(self : ManualTask) -> Field[ExactInteger]

    ManualTask::to_repr

    source

    Message

    source
    pub struct Message {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tMessage.

    Message::documentation

    source
    fn Message::documentation(self : Message) -> Field[ReadOnlyArray[Documentation]]

    Message::equal

    source
    fn Message::equal(Message, Message) -> Bool

    Message::extension_elements

    source
    fn Message::extension_elements(self : Message) -> Field[ExtensionElements]

    Message::from_element

    source
    fn Message::from_element(element : Element) -> Message?

    Message::id

    source
    fn Message::id(self : Message) -> Field[String]

    Message::item_ref

    source
    fn Message::item_ref(self : Message) -> Field[Reference]

    Message::name

    source
    fn Message::name(self : Message) -> Field[String]

    Message::new

    source
    fn Message::new(id? : String, name? : String, item_ref? : Reference, contents? : ArrayView[Content]) -> Message

    Message::not_equal

    source
    fn Message::not_equal(x : Message, y : Message) -> Bool

    Message::to_repr

    source

    MessageEventDefinition

    source
    pub struct MessageEventDefinition {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tMessageEventDefinition.

    MessageEventDefinition::documentation

    source
    fn MessageEventDefinition::documentation(self : MessageEventDefinition) -> Field[ReadOnlyArray[Documentation]]

    MessageEventDefinition::equal

    source

    MessageEventDefinition::extension_elements

    source

    MessageEventDefinition::from_element

    source
    fn MessageEventDefinition::from_element(element : Element) -> MessageEventDefinition?

    MessageEventDefinition::id

    source

    MessageEventDefinition::message_ref

    source

    MessageEventDefinition::new

    source
    fn MessageEventDefinition::new(id? : String, message_ref? : Reference, contents? : ArrayView[Content]) -> MessageEventDefinition

    MessageEventDefinition::not_equal

    source

    MessageEventDefinition::operation_ref

    source

    MessageEventDefinition::to_repr

    source

    MessageFlow

    source
    pub struct MessageFlow {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tMessageFlow.

    MessageFlow::documentation

    source
    fn MessageFlow::documentation(self : MessageFlow) -> Field[ReadOnlyArray[Documentation]]

    MessageFlow::equal

    source
    fn MessageFlow::equal(MessageFlow, MessageFlow) -> Bool

    MessageFlow::extension_elements

    source
    fn MessageFlow::extension_elements(self : MessageFlow) -> Field[ExtensionElements]

    MessageFlow::from_element

    source
    fn MessageFlow::from_element(element : Element) -> MessageFlow?

    MessageFlow::id

    source
    fn MessageFlow::id(self : MessageFlow) -> Field[String]

    MessageFlow::message_ref

    source
    fn MessageFlow::message_ref(self : MessageFlow) -> Field[Reference]

    MessageFlow::name

    source
    fn MessageFlow::name(self : MessageFlow) -> Field[String]

    MessageFlow::new

    source
    fn MessageFlow::new(id? : String, name? : String, source_ref? : Reference, target_ref? : Reference, message_ref? : Reference, contents? : ArrayView[Content]) -> MessageFlow

    MessageFlow::not_equal

    source
    fn MessageFlow::not_equal(x : MessageFlow, y : MessageFlow) -> Bool

    MessageFlow::source_ref

    source
    fn MessageFlow::source_ref(self : MessageFlow) -> Field[Reference]

    MessageFlow::target_ref

    source
    fn MessageFlow::target_ref(self : MessageFlow) -> Field[Reference]

    MessageFlow::to_repr

    source

    MessageFlowAssociation

    source
    pub struct MessageFlowAssociation {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tMessageFlowAssociation.

    MessageFlowAssociation::documentation

    source
    fn MessageFlowAssociation::documentation(self : MessageFlowAssociation) -> Field[ReadOnlyArray[Documentation]]

    MessageFlowAssociation::equal

    source

    MessageFlowAssociation::extension_elements

    source

    MessageFlowAssociation::from_element

    source
    fn MessageFlowAssociation::from_element(element : Element) -> MessageFlowAssociation?

    MessageFlowAssociation::id

    source

    MessageFlowAssociation::inner_message_flow_ref

    source
    fn MessageFlowAssociation::inner_message_flow_ref(self : MessageFlowAssociation) -> Field[Reference]

    MessageFlowAssociation::new

    source
    fn MessageFlowAssociation::new(id? : String, inner_message_flow_ref? : Reference, outer_message_flow_ref? : Reference, contents? : ArrayView[Content]) -> MessageFlowAssociation

    MessageFlowAssociation::not_equal

    source

    MessageFlowAssociation::outer_message_flow_ref

    source
    fn MessageFlowAssociation::outer_message_flow_ref(self : MessageFlowAssociation) -> Field[Reference]

    MessageFlowAssociation::to_repr

    source

    Monitoring

    source
    pub struct Monitoring {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tMonitoring.

    Monitoring::documentation

    source
    fn Monitoring::documentation(self : Monitoring) -> Field[ReadOnlyArray[Documentation]]

    Monitoring::equal

    source
    fn Monitoring::equal(Monitoring, Monitoring) -> Bool

    Monitoring::extension_elements

    source
    fn Monitoring::extension_elements(self : Monitoring) -> Field[ExtensionElements]

    Monitoring::from_element

    source
    fn Monitoring::from_element(element : Element) -> Monitoring?

    Monitoring::id

    source
    fn Monitoring::id(self : Monitoring) -> Field[String]

    Monitoring::new

    source
    fn Monitoring::new(id? : String, contents? : ArrayView[Content]) -> Monitoring

    Monitoring::not_equal

    source
    fn Monitoring::not_equal(x : Monitoring, y : Monitoring) -> Bool

    Monitoring::to_repr

    source

    MultiInstanceFlowCondition

    source
    pub(all) enum MultiInstanceFlowCondition {
      None
      One
      All
      Complex
    } derive(Eq, 
    Debug    )

    Values of the pinned XSD type tMultiInstanceFlowCondition.

    MultiInstanceFlowCondition::equal

    source

    MultiInstanceFlowCondition::not_equal

    source

    MultiInstanceFlowCondition::parse

    source

    MultiInstanceFlowCondition::to_repr

    source

    MultiInstanceFlowCondition::token

    source

    MultiInstanceLoopCharacteristics

    source
    pub struct MultiInstanceLoopCharacteristics {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tMultiInstanceLoopCharacteristics.

    MultiInstanceLoopCharacteristics::behavior

    source

    MultiInstanceLoopCharacteristics::completion_condition

    source

    MultiInstanceLoopCharacteristics::complex_behavior_definition

    source

    MultiInstanceLoopCharacteristics::documentation

    source

    MultiInstanceLoopCharacteristics::equal

    source

    MultiInstanceLoopCharacteristics::extension_elements

    source

    MultiInstanceLoopCharacteristics::from_element

    source

    MultiInstanceLoopCharacteristics::id

    source

    MultiInstanceLoopCharacteristics::input_data_item

    source

    MultiInstanceLoopCharacteristics::is_sequential

    source

    MultiInstanceLoopCharacteristics::loop_cardinality

    source

    MultiInstanceLoopCharacteristics::loop_data_input_ref

    source

    MultiInstanceLoopCharacteristics::loop_data_output_ref

    source

    MultiInstanceLoopCharacteristics::new

    source
    fn MultiInstanceLoopCharacteristics::new(id? : String, is_sequential? : Bool, behavior? : MultiInstanceFlowCondition, one_behavior_event_ref? : Reference, none_behavior_event_ref? : Reference, contents? : ArrayView[Content]) -> MultiInstanceLoopCharacteristics

    MultiInstanceLoopCharacteristics::none_behavior_event_ref

    source

    MultiInstanceLoopCharacteristics::not_equal

    source

    MultiInstanceLoopCharacteristics::one_behavior_event_ref

    source

    MultiInstanceLoopCharacteristics::output_data_item

    source

    MultiInstanceLoopCharacteristics::to_repr

    source

    NodeCategory

    source
    pub(all) enum NodeCategory {
      Document
      Definitions
      Process
      Activity
      Event
      Gateway
      SequenceFlow
      Collaboration
      Participant
      Lane
      Choreography
      ChoreographyActivity
      Conversation
      ConversationLink
      DiagramInterchange
      Extension
      Other
      Text
      Comment
      ProcessingInstruction
    } derive(Eq, 
    Debug    )

    NodeCategory::equal

    source

    NodeCategory::not_equal

    source
    fn NodeCategory::not_equal(x : NodeCategory, y : NodeCategory) -> Bool

    NodeCategory::to_repr

    source

    NodeField

    source
    pub struct NodeField {
      field : PathField
      attributes : ReadOnlyArray[Attribute]
      children : ReadOnlyArray[NodeRef]
    } derive(Eq, 
    Debug    )

    NodeField::equal

    source
    fn NodeField::equal(NodeField, NodeField) -> Bool

    NodeField::not_equal

    source
    fn NodeField::not_equal(x : NodeField, y : NodeField) -> Bool

    NodeField::to_repr

    source

    NodeHandle

    source
    pub struct NodeHandle {
      ordinal : Int
      // private fields
    }

    impl Eq for NodeHandle
    impl Debug for NodeHandle

    NodeHandle::equal

    source
    fn NodeHandle::equal(a : NodeHandle, b : NodeHandle) -> Bool

    NodeHandle::not_equal

    source
    fn NodeHandle::not_equal(x : NodeHandle, y : NodeHandle) -> Bool

    NodeHandle::resource_id

    source
    fn NodeHandle::resource_id(self : NodeHandle) -> String?

    NodeHandle::to_repr

    source

    NodeLookup

    source
    pub(all) enum NodeLookup {
      Found(NodeRef)
      DocumentMismatch
      InvalidHandle
    } derive(Eq, 
    Debug    )

    NodeLookup::equal

    source
    fn NodeLookup::equal(NodeLookup, NodeLookup) -> Bool

    NodeLookup::not_equal

    source
    fn NodeLookup::not_equal(x : NodeLookup, y : NodeLookup) -> Bool

    NodeLookup::to_repr

    source

    NodePath

    source
    pub struct NodePath {
      // private fields
    }

    The view is constant size; steps are materialized only when requested.
    impl Eq for NodePath
    impl Debug for NodePath

    NodePath::depth

    source
    fn NodePath::depth(self : NodePath) -> Int

    NodePath::equal

    source
    fn NodePath::equal(a : NodePath, b : NodePath) -> Bool

    NodePath::not_equal

    source
    fn NodePath::not_equal(x : NodePath, y : NodePath) -> Bool

    NodePath::resolve

    source
    fn NodePath::resolve(self : NodePath, tree : DocumentTree) -> NodeLookup

    NodePath::steps

    source
    fn NodePath::steps(self : NodePath) -> ReadOnlyArray[PathStep]

    NodePath::to_repr

    source

    NodeRef

    source
    pub struct NodeRef {
      // private fields
    }

    impl Eq for NodeRef
    impl Debug for NodeRef

    NodeRef::attributes

    source
    fn NodeRef::attributes(self : NodeRef) -> ReadOnlyArray[Attribute]

    NodeRef::category

    source
    fn NodeRef::category(self : NodeRef) -> NodeCategory

    NodeRef::children

    source
    fn NodeRef::children(self : NodeRef) -> ReadOnlyArray[NodeRef]

    NodeRef::depth

    source
    fn NodeRef::depth(self : NodeRef) -> Int

    NodeRef::element

    source
    fn NodeRef::element(self : NodeRef) -> Element?

    NodeRef::equal

    source
    fn NodeRef::equal(a : NodeRef, b : NodeRef) -> Bool

    NodeRef::field

    source
    fn NodeRef::field(self : NodeRef, field : PathField) -> NodeField?

    NodeRef::fields

    source
    fn NodeRef::fields(self : NodeRef) -> ReadOnlyArray[NodeField]

    NodeRef::handle

    source
    fn NodeRef::handle(self : NodeRef) -> NodeHandle

    NodeRef::id

    source
    fn NodeRef::id(self : NodeRef) -> String?

    NodeRef::kind

    source
    fn NodeRef::kind(self : NodeRef) -> Kind?

    NodeRef::location

    source
    fn NodeRef::location(self : NodeRef) -> Location?

    NodeRef::not_equal

    source
    fn NodeRef::not_equal(x : NodeRef, y : NodeRef) -> Bool

    NodeRef::parent

    source
    fn NodeRef::parent(self : NodeRef) -> NodeRef?

    NodeRef::path

    source
    fn NodeRef::path(self : NodeRef) -> NodePath

    NodeRef::resource_id

    source
    fn NodeRef::resource_id(self : NodeRef) -> String?

    NodeRef::scalar

    source
    fn NodeRef::scalar(self : NodeRef, name : ExpandedName) -> Scalar?

    NodeRef::span

    source
    fn NodeRef::span(self : NodeRef) -> Span?

    NodeRef::step

    source
    fn NodeRef::step(self : NodeRef) -> PathStep?

    NodeRef::to_repr

    source

    NodeRef::value

    source
    fn NodeRef::value(self : NodeRef) -> NodeValue

    NodeValue

    source
    pub(all) enum NodeValue {
      Document
      Element(Element)
      Text(String)
      Comment(String)
      ProcessingInstruction(target~ : String, data~ : String)
    } derive(Eq, 
    Debug    )

    NodeValue::equal

    source
    fn NodeValue::equal(NodeValue, NodeValue) -> Bool

    NodeValue::not_equal

    source
    fn NodeValue::not_equal(x : NodeValue, y : NodeValue) -> Bool

    NodeValue::to_repr

    source

    Operation

    source
    pub struct Operation {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tOperation.

    Operation::documentation

    source
    fn Operation::documentation(self : Operation) -> Field[ReadOnlyArray[Documentation]]

    Operation::equal

    source
    fn Operation::equal(Operation, Operation) -> Bool

    Operation::error_ref

    source
    fn Operation::error_ref(self : Operation) -> Field[ReadOnlyArray[Reference]]

    Operation::extension_elements

    source
    fn Operation::extension_elements(self : Operation) -> Field[ExtensionElements]

    Operation::from_element

    source
    fn Operation::from_element(element : Element) -> Operation?

    Operation::id

    source
    fn Operation::id(self : Operation) -> Field[String]

    Operation::implementation_ref

    source
    fn Operation::implementation_ref(self : Operation) -> Field[Reference]

    Operation::in_message_ref

    source
    fn Operation::in_message_ref(self : Operation) -> Field[Reference]

    Operation::name

    source
    fn Operation::name(self : Operation) -> Field[String]

    Operation::new

    source
    fn Operation::new(id? : String, name? : String, implementation_ref? : Reference, contents? : ArrayView[Content]) -> Operation

    Operation::not_equal

    source
    fn Operation::not_equal(x : Operation, y : Operation) -> Bool

    Operation::out_message_ref

    source
    fn Operation::out_message_ref(self : Operation) -> Field[Reference]

    Operation::to_repr

    source

    OutputSet

    source
    pub struct OutputSet {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tOutputSet.

    OutputSet::data_output_refs

    source
    fn OutputSet::data_output_refs(self : OutputSet) -> Field[ReadOnlyArray[Reference]]

    OutputSet::documentation

    source
    fn OutputSet::documentation(self : OutputSet) -> Field[ReadOnlyArray[Documentation]]

    OutputSet::equal

    source
    fn OutputSet::equal(OutputSet, OutputSet) -> Bool

    OutputSet::extension_elements

    source
    fn OutputSet::extension_elements(self : OutputSet) -> Field[ExtensionElements]

    OutputSet::from_element

    source
    fn OutputSet::from_element(element : Element) -> OutputSet?

    OutputSet::id

    source
    fn OutputSet::id(self : OutputSet) -> Field[String]

    OutputSet::input_set_refs

    source
    fn OutputSet::input_set_refs(self : OutputSet) -> Field[ReadOnlyArray[Reference]]

    OutputSet::name

    source
    fn OutputSet::name(self : OutputSet) -> Field[String]

    OutputSet::new

    source
    fn OutputSet::new(id? : String, name? : String, contents? : ArrayView[Content]) -> OutputSet

    OutputSet::not_equal

    source
    fn OutputSet::not_equal(x : OutputSet, y : OutputSet) -> Bool

    OutputSet::optional_output_refs

    source
    fn OutputSet::optional_output_refs(self : OutputSet) -> Field[ReadOnlyArray[Reference]]

    OutputSet::to_repr

    source

    OutputSet::while_executing_output_refs

    source
    fn OutputSet::while_executing_output_refs(self : OutputSet) -> Field[ReadOnlyArray[Reference]]

    ParallelGateway

    source
    pub struct ParallelGateway {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tParallelGateway.

    ParallelGateway::auditing

    source

    ParallelGateway::category_value_ref

    source
    fn ParallelGateway::category_value_ref(self : ParallelGateway) -> Field[ReadOnlyArray[Reference]]

    ParallelGateway::documentation

    source
    fn ParallelGateway::documentation(self : ParallelGateway) -> Field[ReadOnlyArray[Documentation]]

    ParallelGateway::equal

    source

    ParallelGateway::extension_elements

    source
    fn ParallelGateway::extension_elements(self : ParallelGateway) -> Field[ExtensionElements]

    ParallelGateway::from_element

    source
    fn ParallelGateway::from_element(element : Element) -> ParallelGateway?

    ParallelGateway::gateway_direction

    source
    fn ParallelGateway::gateway_direction(self : ParallelGateway) -> Field[GatewayDirection]

    ParallelGateway::id

    source
    fn ParallelGateway::id(self : ParallelGateway) -> Field[String]

    ParallelGateway::incoming

    source
    fn ParallelGateway::incoming(self : ParallelGateway) -> Field[ReadOnlyArray[Reference]]

    ParallelGateway::monitoring

    source
    fn ParallelGateway::monitoring(self : ParallelGateway) -> Field[Monitoring]

    ParallelGateway::name

    source
    fn ParallelGateway::name(self : ParallelGateway) -> Field[String]

    ParallelGateway::new

    source
    fn ParallelGateway::new(id? : String, name? : String, gateway_direction? : GatewayDirection, contents? : ArrayView[Content]) -> ParallelGateway

    ParallelGateway::not_equal

    source
    fn ParallelGateway::not_equal(x : ParallelGateway, y : ParallelGateway) -> Bool

    ParallelGateway::outgoing

    source
    fn ParallelGateway::outgoing(self : ParallelGateway) -> Field[ReadOnlyArray[Reference]]

    ParallelGateway::to_repr

    source

    Participant

    source
    pub struct Participant {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tParticipant.

    Participant::documentation

    source
    fn Participant::documentation(self : Participant) -> Field[ReadOnlyArray[Documentation]]

    Participant::end_point_ref

    source
    fn Participant::end_point_ref(self : Participant) -> Field[ReadOnlyArray[Reference]]

    Participant::equal

    source
    fn Participant::equal(Participant, Participant) -> Bool

    Participant::extension_elements

    source
    fn Participant::extension_elements(self : Participant) -> Field[ExtensionElements]

    Participant::from_element

    source
    fn Participant::from_element(element : Element) -> Participant?

    Participant::id

    source
    fn Participant::id(self : Participant) -> Field[String]

    Participant::interface_ref

    source
    fn Participant::interface_ref(self : Participant) -> Field[ReadOnlyArray[Reference]]

    Participant::name

    source
    fn Participant::name(self : Participant) -> Field[String]

    Participant::new

    source
    fn Participant::new(id? : String, name? : String, process_ref? : Reference, contents? : ArrayView[Content]) -> Participant

    Participant::not_equal

    source
    fn Participant::not_equal(x : Participant, y : Participant) -> Bool

    Participant::participant_multiplicity

    source
    fn Participant::participant_multiplicity(self : Participant) -> Field[ParticipantMultiplicity]

    Participant::process_ref

    source
    fn Participant::process_ref(self : Participant) -> Field[Reference]

    Participant::to_repr

    source

    ParticipantAssociation

    source
    pub struct ParticipantAssociation {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tParticipantAssociation.

    ParticipantAssociation::documentation

    source
    fn ParticipantAssociation::documentation(self : ParticipantAssociation) -> Field[ReadOnlyArray[Documentation]]

    ParticipantAssociation::equal

    source

    ParticipantAssociation::extension_elements

    source

    ParticipantAssociation::from_element

    source
    fn ParticipantAssociation::from_element(element : Element) -> ParticipantAssociation?

    ParticipantAssociation::id

    source

    ParticipantAssociation::inner_participant_ref

    source
    fn ParticipantAssociation::inner_participant_ref(self : ParticipantAssociation) -> Field[Reference]

    ParticipantAssociation::new

    source
    fn ParticipantAssociation::new(id? : String, contents? : ArrayView[Content]) -> ParticipantAssociation

    ParticipantAssociation::not_equal

    source

    ParticipantAssociation::outer_participant_ref

    source
    fn ParticipantAssociation::outer_participant_ref(self : ParticipantAssociation) -> Field[Reference]

    ParticipantAssociation::to_repr

    source

    ParticipantMultiplicity

    source
    pub struct ParticipantMultiplicity {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tParticipantMultiplicity.

    ParticipantMultiplicity::documentation

    source
    fn ParticipantMultiplicity::documentation(self : ParticipantMultiplicity) -> Field[ReadOnlyArray[Documentation]]

    ParticipantMultiplicity::equal

    source

    ParticipantMultiplicity::extension_elements

    source

    ParticipantMultiplicity::from_element

    source

    ParticipantMultiplicity::id

    source

    ParticipantMultiplicity::maximum

    source

    ParticipantMultiplicity::minimum

    source

    ParticipantMultiplicity::new

    source
    fn ParticipantMultiplicity::new(id? : String, minimum? : ExactInteger, maximum? : ExactInteger, contents? : ArrayView[Content]) -> ParticipantMultiplicity

    ParticipantMultiplicity::not_equal

    source

    ParticipantMultiplicity::to_repr

    source

    PartnerEntity

    source
    pub struct PartnerEntity {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tPartnerEntity.

    PartnerEntity::documentation

    source
    fn PartnerEntity::documentation(self : PartnerEntity) -> Field[ReadOnlyArray[Documentation]]

    PartnerEntity::equal

    source

    PartnerEntity::extension_elements

    source
    fn PartnerEntity::extension_elements(self : PartnerEntity) -> Field[ExtensionElements]

    PartnerEntity::from_element

    source
    fn PartnerEntity::from_element(element : Element) -> PartnerEntity?

    PartnerEntity::id

    source
    fn PartnerEntity::id(self : PartnerEntity) -> Field[String]

    PartnerEntity::name

    source
    fn PartnerEntity::name(self : PartnerEntity) -> Field[String]

    PartnerEntity::new

    source
    fn PartnerEntity::new(id? : String, name? : String, contents? : ArrayView[Content]) -> PartnerEntity

    PartnerEntity::not_equal

    source
    fn PartnerEntity::not_equal(x : PartnerEntity, y : PartnerEntity) -> Bool

    PartnerEntity::participant_ref

    source
    fn PartnerEntity::participant_ref(self : PartnerEntity) -> Field[ReadOnlyArray[Reference]]

    PartnerEntity::to_repr

    source

    PartnerRole

    source
    pub struct PartnerRole {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tPartnerRole.

    PartnerRole::documentation

    source
    fn PartnerRole::documentation(self : PartnerRole) -> Field[ReadOnlyArray[Documentation]]

    PartnerRole::equal

    source
    fn PartnerRole::equal(PartnerRole, PartnerRole) -> Bool

    PartnerRole::extension_elements

    source
    fn PartnerRole::extension_elements(self : PartnerRole) -> Field[ExtensionElements]

    PartnerRole::from_element

    source
    fn PartnerRole::from_element(element : Element) -> PartnerRole?

    PartnerRole::id

    source
    fn PartnerRole::id(self : PartnerRole) -> Field[String]

    PartnerRole::name

    source
    fn PartnerRole::name(self : PartnerRole) -> Field[String]

    PartnerRole::new

    source
    fn PartnerRole::new(id? : String, name? : String, contents? : ArrayView[Content]) -> PartnerRole

    PartnerRole::not_equal

    source
    fn PartnerRole::not_equal(x : PartnerRole, y : PartnerRole) -> Bool

    PartnerRole::participant_ref

    source
    fn PartnerRole::participant_ref(self : PartnerRole) -> Field[ReadOnlyArray[Reference]]

    PartnerRole::to_repr

    source

    PathField

    source
    pub(all) enum PathField {
      Named(ExpandedName)
      Text
      Comment
      ProcessingInstruction
      Root
      Prolog
      Epilog
    } derive(Eq, 
    Debug    )

    PathField::equal

    source
    fn PathField::equal(PathField, PathField) -> Bool

    PathField::not_equal

    source
    fn PathField::not_equal(x : PathField, y : PathField) -> Bool

    PathField::to_repr

    source

    PathStep

    source
    pub struct PathStep {
      field : PathField
      index : Int
      content_index : Int
    } derive(Eq, 
    Debug    )

    Index within a named field, plus the absolute ordered-content index.

    PathStep::equal

    source
    fn PathStep::equal(PathStep, PathStep) -> Bool

    PathStep::not_equal

    source
    fn PathStep::not_equal(x : PathStep, y : PathStep) -> Bool

    PathStep::to_repr

    source

    Performer

    source
    pub struct Performer {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tPerformer.

    Performer::documentation

    source
    fn Performer::documentation(self : Performer) -> Field[ReadOnlyArray[Documentation]]

    Performer::equal

    source
    fn Performer::equal(Performer, Performer) -> Bool

    Performer::extension_elements

    source
    fn Performer::extension_elements(self : Performer) -> Field[ExtensionElements]

    Performer::from_element

    source
    fn Performer::from_element(element : Element) -> Performer?

    Performer::id

    source
    fn Performer::id(self : Performer) -> Field[String]

    Performer::name

    source
    fn Performer::name(self : Performer) -> Field[String]

    Performer::new

    source
    fn Performer::new(id? : String, name? : String, contents? : ArrayView[Content]) -> Performer

    Performer::not_equal

    source
    fn Performer::not_equal(x : Performer, y : Performer) -> Bool

    Performer::resource_assignment_expression

    source
    fn Performer::resource_assignment_expression(self : Performer) -> Field[ResourceAssignmentExpression]

    Performer::resource_parameter_binding

    source
    fn Performer::resource_parameter_binding(self : Performer) -> Field[ReadOnlyArray[ResourceParameterBinding]]

    Performer::resource_ref

    source
    fn Performer::resource_ref(self : Performer) -> Field[Reference]

    Performer::to_repr

    source

    Position

    source
    pub struct Position {
      offset : Int
      line : Int
      column : Int
    } derive(Eq, 
    Debug    )

    Position::equal

    source
    fn Position::equal(Position, Position) -> Bool

    Position::not_equal

    source
    fn Position::not_equal(x : Position, y : Position) -> Bool

    Position::to_repr

    source

    PotentialOwner

    source
    pub struct PotentialOwner {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tPotentialOwner.

    PotentialOwner::documentation

    source
    fn PotentialOwner::documentation(self : PotentialOwner) -> Field[ReadOnlyArray[Documentation]]

    PotentialOwner::equal

    source

    PotentialOwner::extension_elements

    source
    fn PotentialOwner::extension_elements(self : PotentialOwner) -> Field[ExtensionElements]

    PotentialOwner::from_element

    source
    fn PotentialOwner::from_element(element : Element) -> PotentialOwner?

    PotentialOwner::id

    source
    fn PotentialOwner::id(self : PotentialOwner) -> Field[String]

    PotentialOwner::name

    source
    fn PotentialOwner::name(self : PotentialOwner) -> Field[String]

    PotentialOwner::new

    source
    fn PotentialOwner::new(id? : String, name? : String, contents? : ArrayView[Content]) -> PotentialOwner

    PotentialOwner::not_equal

    source
    fn PotentialOwner::not_equal(x : PotentialOwner, y : PotentialOwner) -> Bool

    PotentialOwner::resource_assignment_expression

    source
    fn PotentialOwner::resource_assignment_expression(self : PotentialOwner) -> Field[ResourceAssignmentExpression]

    PotentialOwner::resource_parameter_binding

    source
    fn PotentialOwner::resource_parameter_binding(self : PotentialOwner) -> Field[ReadOnlyArray[ResourceParameterBinding]]

    PotentialOwner::resource_ref

    source
    fn PotentialOwner::resource_ref(self : PotentialOwner) -> Field[Reference]

    PotentialOwner::to_repr

    source

    Process

    source
    pub struct Process {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tProcess.

    Process::artifact

    source
    fn Process::artifact(self : Process) -> Field[ReadOnlyArray[Artifact]]

    Process::auditing

    source
    fn Process::auditing(self : Process) -> Field[Auditing]

    Process::correlation_subscription

    source
    fn Process::correlation_subscription(self : Process) -> Field[ReadOnlyArray[CorrelationSubscription]]

    Process::definitional_collaboration_ref

    source
    fn Process::definitional_collaboration_ref(self : Process) -> Field[Reference]

    Process::documentation

    source
    fn Process::documentation(self : Process) -> Field[ReadOnlyArray[Documentation]]

    Process::equal

    source
    fn Process::equal(Process, Process) -> Bool

    Process::extension_elements

    source
    fn Process::extension_elements(self : Process) -> Field[ExtensionElements]

    Process::flow_element

    source
    fn Process::flow_element(self : Process) -> Field[ReadOnlyArray[FlowElement]]

    Process::from_element

    source
    fn Process::from_element(element : Element) -> Process?

    Process::id

    source
    fn Process::id(self : Process) -> Field[String]

    Process::io_binding

    source
    fn Process::io_binding(self : Process) -> Field[ReadOnlyArray[InputOutputBinding]]

    Process::io_specification

    source
    fn Process::io_specification(self : Process) -> Field[InputOutputSpecification]

    Process::is_closed

    source
    fn Process::is_closed(self : Process) -> Field[Bool]

    Process::is_executable

    source
    fn Process::is_executable(self : Process) -> Field[Bool]

    Process::lane_set

    source
    fn Process::lane_set(self : Process) -> Field[ReadOnlyArray[LaneSet]]

    Process::monitoring

    source
    fn Process::monitoring(self : Process) -> Field[Monitoring]

    Process::name

    source
    fn Process::name(self : Process) -> Field[String]

    Process::new

    source
    fn Process::new(id? : String, name? : String, process_type? : ProcessType, is_closed? : Bool, is_executable? : Bool, definitional_collaboration_ref? : Reference, contents? : ArrayView[Content]) -> Process

    Process::not_equal

    source
    fn Process::not_equal(x : Process, y : Process) -> Bool

    Process::process_type

    source
    fn Process::process_type(self : Process) -> Field[ProcessType]

    Process::property

    source
    fn Process::property(self : Process) -> Field[ReadOnlyArray[Property]]

    Process::resource_role

    source
    fn Process::resource_role(self : Process) -> Field[ReadOnlyArray[ResourceRole]]

    Process::supported_interface_ref

    source
    fn Process::supported_interface_ref(self : Process) -> Field[ReadOnlyArray[Reference]]

    Process::supports

    source
    fn Process::supports(self : Process) -> Field[ReadOnlyArray[Reference]]

    Process::to_repr

    source

    ProcessType

    source
    pub(all) enum ProcessType {
      None
      Public
      Private
    } derive(Eq, 
    Debug    )

    Values of the pinned XSD type tProcessType.

    ProcessType::equal

    source
    fn ProcessType::equal(ProcessType, ProcessType) -> Bool

    ProcessType::not_equal

    source
    fn ProcessType::not_equal(x : ProcessType, y : ProcessType) -> Bool

    ProcessType::parse

    source
    fn ProcessType::parse(token : String) -> ProcessType?

    ProcessType::to_repr

    source

    ProcessType::token

    source
    fn ProcessType::token(self : ProcessType) -> String

    Property

    source
    pub struct Property {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tProperty.

    Property::data_state

    source
    fn Property::data_state(self : Property) -> Field[DataState]

    Property::documentation

    source
    fn Property::documentation(self : Property) -> Field[ReadOnlyArray[Documentation]]

    Property::equal

    source
    fn Property::equal(Property, Property) -> Bool

    Property::extension_elements

    source
    fn Property::extension_elements(self : Property) -> Field[ExtensionElements]

    Property::from_element

    source
    fn Property::from_element(element : Element) -> Property?

    Property::id

    source
    fn Property::id(self : Property) -> Field[String]

    Property::item_subject_ref

    source
    fn Property::item_subject_ref(self : Property) -> Field[Reference]

    Property::name

    source
    fn Property::name(self : Property) -> Field[String]

    Property::new

    source
    fn Property::new(id? : String, name? : String, item_subject_ref? : Reference, contents? : ArrayView[Content]) -> Property

    Property::not_equal

    source
    fn Property::not_equal(x : Property, y : Property) -> Bool

    Property::to_repr

    source

    ReachabilityResult

    source
    pub(all) enum ReachabilityResult {
      Complete(ReadOnlyArray[GraphNode])
      Failed(GraphFailure)
    } derive(Eq, 
    Debug    )

    ReachabilityResult::equal

    source

    ReachabilityResult::not_equal

    source

    ReachabilityResult::to_repr

    source

    ReadResult

    source
    pub struct ReadResult {
      tree : Cst
      document : Document?
      source_map : SourceMap?
      diagnostics : ReadOnlyArray[Diagnostic]
    } derive(Eq, 
    Debug    )

    ReadResult::equal

    source
    fn ReadResult::equal(ReadResult, ReadResult) -> Bool

    ReadResult::not_equal

    source
    fn ReadResult::not_equal(x : ReadResult, y : ReadResult) -> Bool

    ReadResult::to_repr

    source

    ReceiveTask

    source
    pub struct ReceiveTask {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tReceiveTask.

    ReceiveTask::auditing

    source
    fn ReceiveTask::auditing(self : ReceiveTask) -> Field[Auditing]

    ReceiveTask::category_value_ref

    source
    fn ReceiveTask::category_value_ref(self : ReceiveTask) -> Field[ReadOnlyArray[Reference]]

    ReceiveTask::completion_quantity

    source
    fn ReceiveTask::completion_quantity(self : ReceiveTask) -> Field[ExactInteger]

    ReceiveTask::data_input_association

    source
    fn ReceiveTask::data_input_association(self : ReceiveTask) -> Field[ReadOnlyArray[DataInputAssociation]]

    ReceiveTask::data_output_association

    source
    fn ReceiveTask::data_output_association(self : ReceiveTask) -> Field[ReadOnlyArray[DataOutputAssociation]]

    ReceiveTask::default_

    source
    fn ReceiveTask::default_(self : ReceiveTask) -> Field[Reference]

    ReceiveTask::documentation

    source
    fn ReceiveTask::documentation(self : ReceiveTask) -> Field[ReadOnlyArray[Documentation]]

    ReceiveTask::equal

    source
    fn ReceiveTask::equal(ReceiveTask, ReceiveTask) -> Bool

    ReceiveTask::extension_elements

    source
    fn ReceiveTask::extension_elements(self : ReceiveTask) -> Field[ExtensionElements]

    ReceiveTask::from_element

    source
    fn ReceiveTask::from_element(element : Element) -> ReceiveTask?

    ReceiveTask::id

    source
    fn ReceiveTask::id(self : ReceiveTask) -> Field[String]

    ReceiveTask::implementation

    source
    fn ReceiveTask::implementation(self : ReceiveTask) -> Field[Implementation]

    ReceiveTask::incoming

    source
    fn ReceiveTask::incoming(self : ReceiveTask) -> Field[ReadOnlyArray[Reference]]

    ReceiveTask::instantiate

    source
    fn ReceiveTask::instantiate(self : ReceiveTask) -> Field[Bool]

    ReceiveTask::io_specification

    source
    fn ReceiveTask::io_specification(self : ReceiveTask) -> Field[InputOutputSpecification]

    ReceiveTask::is_for_compensation

    source
    fn ReceiveTask::is_for_compensation(self : ReceiveTask) -> Field[Bool]

    ReceiveTask::loop_characteristics

    source
    fn ReceiveTask::loop_characteristics(self : ReceiveTask) -> Field[LoopCharacteristics]

    ReceiveTask::message_ref

    source
    fn ReceiveTask::message_ref(self : ReceiveTask) -> Field[Reference]

    ReceiveTask::monitoring

    source
    fn ReceiveTask::monitoring(self : ReceiveTask) -> Field[Monitoring]

    ReceiveTask::name

    source
    fn ReceiveTask::name(self : ReceiveTask) -> Field[String]

    ReceiveTask::new

    source
    fn ReceiveTask::new(id? : String, name? : String, is_for_compensation? : Bool, start_quantity? : ExactInteger, completion_quantity? : ExactInteger, default_? : Reference, implementation? : Implementation, instantiate? : Bool, message_ref? : Reference, operation_ref? : Reference, contents? : ArrayView[Content]) -> ReceiveTask

    ReceiveTask::not_equal

    source
    fn ReceiveTask::not_equal(x : ReceiveTask, y : ReceiveTask) -> Bool

    ReceiveTask::operation_ref

    source
    fn ReceiveTask::operation_ref(self : ReceiveTask) -> Field[Reference]

    ReceiveTask::outgoing

    source
    fn ReceiveTask::outgoing(self : ReceiveTask) -> Field[ReadOnlyArray[Reference]]

    ReceiveTask::property

    source
    fn ReceiveTask::property(self : ReceiveTask) -> Field[ReadOnlyArray[Property]]

    ReceiveTask::resource_role

    source
    fn ReceiveTask::resource_role(self : ReceiveTask) -> Field[ReadOnlyArray[ResourceRole]]

    ReceiveTask::start_quantity

    source
    fn ReceiveTask::start_quantity(self : ReceiveTask) -> Field[ExactInteger]

    ReceiveTask::to_repr

    source

    Reference

    source
    pub struct Reference {
      kind : ReferenceKind
      spelling : String
      name : ExpandedName?
    } derive(
    Debug    )

    Namespace identity and original spelling are separate. A missing name marks an unresolved namespace binding, not a missing external target document.
    impl Eq for Reference

    Reference::equal

    source
    fn Reference::equal(a : Reference, b : Reference) -> Bool

    Reference::new

    source
    fn Reference::new(name : ExpandedName, kind? : ReferenceKind) -> Reference

    Reference::not_equal

    source
    fn Reference::not_equal(x : Reference, y : Reference) -> Bool

    Reference::parse

    source
    fn Reference::parse(spelling : String, bindings? : ArrayView[(String, String)], kind? : ReferenceKind) -> Reference

    Reference::to_repr

    source

    ReferenceKind

    source
    pub(all) enum ReferenceKind {
      Id
      QName
    } derive(Eq, 
    Debug    )

    ReferenceKind::equal

    source

    ReferenceKind::not_equal

    source
    fn ReferenceKind::not_equal(x : ReferenceKind, y : ReferenceKind) -> Bool

    ReferenceKind::to_repr

    source

    ReferenceResolution

    source
    pub(all) enum ReferenceResolution {
      Found(ResolvedElement)
      External(ResolvedSymbol)
      Ambiguous(ReadOnlyArray[ResolvedElement], ReadOnlyArray[ResolvedSymbol])
      Unresolved
      Invalid
      Limit
    } derive(Eq, 
    Debug    )

    ReferenceResolution::equal

    source

    ReferenceResolution::not_equal

    source

    ReferenceResolution::to_repr

    source

    ReferenceResult

    source
    pub struct ReferenceResult {
      index : DocumentIndex
      references : ReadOnlyArray[ResolvedReference]
      findings : ReadOnlyArray[ValidationFinding]
      complete : Bool
      // private fields
    } derive(
    Debug    )

    ReferenceResult::indexed_resources

    source
    fn ReferenceResult::indexed_resources(self : ReferenceResult) -> ReadOnlyArray[IndexedResource]

    ReferenceResult::resolve

    source
    fn ReferenceResult::resolve(self : ReferenceResult, reference : Reference) -> ReferenceResolution

    Lookup uses the same direct/transitive import closure as field resolution.

    ReferenceResult::to_repr

    source

    ReferenceRule

    source
    pub struct ReferenceRule {
      owner : TypeId
      field : ExpandedName
      kind : SchemaFieldKind
      target : ReferenceTarget
    } derive(Eq, 
    Debug    )

    ReferenceRule::equal

    source

    ReferenceRule::not_equal

    source
    fn ReferenceRule::not_equal(x : ReferenceRule, y : ReferenceRule) -> Bool

    ReferenceRule::to_repr

    source

    ReferenceTarget

    source
    pub(all) enum ReferenceTarget {
      Bpmn(TypeId)
      AnyElement
      InteractionNode
      ItemAwareElement
      Plane
      External
    } derive(Eq, 
    Debug    )

    Semantic reference targets supplement the frozen XSD's QName/IDREF fields. Targets follow the BPMN 2.0.2 metamodel; external language symbols are supplied explicitly and are never parsed or executed by this module.

    ReferenceTarget::equal

    source

    ReferenceTarget::not_equal

    source
    fn ReferenceTarget::not_equal(x : ReferenceTarget, y : ReferenceTarget) -> Bool

    ReferenceTarget::to_repr

    source

    Relationship

    source
    pub struct Relationship {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tRelationship.

    Relationship::direction

    source

    Relationship::documentation

    source
    fn Relationship::documentation(self : Relationship) -> Field[ReadOnlyArray[Documentation]]

    Relationship::equal

    source

    Relationship::extension_elements

    source
    fn Relationship::extension_elements(self : Relationship) -> Field[ExtensionElements]

    Relationship::from_element

    source
    fn Relationship::from_element(element : Element) -> Relationship?

    Relationship::id

    source
    fn Relationship::id(self : Relationship) -> Field[String]

    Relationship::new

    source
    fn Relationship::new(id? : String, type_? : String, direction? : RelationshipDirection, contents? : ArrayView[Content]) -> Relationship

    Relationship::not_equal

    source
    fn Relationship::not_equal(x : Relationship, y : Relationship) -> Bool

    Relationship::source

    source
    fn Relationship::source(self : Relationship) -> Field[ReadOnlyArray[Reference]]

    Relationship::target

    source
    fn Relationship::target(self : Relationship) -> Field[ReadOnlyArray[Reference]]

    Relationship::to_repr

    source

    Relationship::type_

    source
    fn Relationship::type_(self : Relationship) -> Field[String]

    RelationshipDirection

    source
    pub(all) enum RelationshipDirection {
      None
      Forward
      Backward
      Both
    } derive(Eq, 
    Debug    )

    Values of the pinned XSD type tRelationshipDirection.

    RelationshipDirection::equal

    source

    RelationshipDirection::not_equal

    source

    RelationshipDirection::parse

    source
    fn RelationshipDirection::parse(token : String) -> RelationshipDirection?

    RelationshipDirection::to_repr

    source

    RelationshipDirection::token

    source
    fn RelationshipDirection::token(self : RelationshipDirection) -> String

    Rendering

    source
    pub struct Rendering {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tRendering.

    Rendering::documentation

    source
    fn Rendering::documentation(self : Rendering) -> Field[ReadOnlyArray[Documentation]]

    Rendering::equal

    source
    fn Rendering::equal(Rendering, Rendering) -> Bool

    Rendering::extension_elements

    source
    fn Rendering::extension_elements(self : Rendering) -> Field[ExtensionElements]

    Rendering::from_element

    source
    fn Rendering::from_element(element : Element) -> Rendering?

    Rendering::id

    source
    fn Rendering::id(self : Rendering) -> Field[String]

    Rendering::new

    source
    fn Rendering::new(id? : String, contents? : ArrayView[Content]) -> Rendering

    Rendering::not_equal

    source
    fn Rendering::not_equal(x : Rendering, y : Rendering) -> Bool

    Rendering::to_repr

    source

    ResolvedElement

    source
    pub struct ResolvedElement {
      resource_id : String?
      node : IndexedElement
    } derive(Eq, 
    Debug    )

    ResolvedElement::equal

    source

    ResolvedElement::not_equal

    source
    fn ResolvedElement::not_equal(x : ResolvedElement, y : ResolvedElement) -> Bool

    ResolvedElement::to_repr

    source

    ResolvedReference

    source
    pub struct ResolvedReference {
      source : IndexedElement
      field : ExpandedName
      value : Reference
      target : ReferenceTarget
      resolution : ReferenceResolution
    } derive(Eq, 
    Debug    )

    ResolvedReference::equal

    source

    ResolvedReference::not_equal

    source
    fn ResolvedReference::not_equal(x : ResolvedReference, y : ResolvedReference) -> Bool

    ResolvedReference::to_repr

    source

    ResolvedSymbol

    source
    pub struct ResolvedSymbol {
      resource_id : String
      name : ExpandedName
    } derive(Eq, 
    Debug    )

    ResolvedSymbol::equal

    source

    ResolvedSymbol::new

    source
    fn ResolvedSymbol::new(resource_id : String, name : ExpandedName) -> ResolvedSymbol

    ResolvedSymbol::not_equal

    source
    fn ResolvedSymbol::not_equal(x : ResolvedSymbol, y : ResolvedSymbol) -> Bool

    ResolvedSymbol::to_repr

    source

    Resource

    source
    pub struct Resource {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tResource.

    Resource::documentation

    source
    fn Resource::documentation(self : Resource) -> Field[ReadOnlyArray[Documentation]]

    Resource::equal

    source
    fn Resource::equal(Resource, Resource) -> Bool

    Resource::extension_elements

    source
    fn Resource::extension_elements(self : Resource) -> Field[ExtensionElements]

    Resource::from_element

    source
    fn Resource::from_element(element : Element) -> Resource?

    Resource::id

    source
    fn Resource::id(self : Resource) -> Field[String]

    Resource::name

    source
    fn Resource::name(self : Resource) -> Field[String]

    Resource::new

    source
    fn Resource::new(id? : String, name? : String, contents? : ArrayView[Content]) -> Resource

    Resource::not_equal

    source
    fn Resource::not_equal(x : Resource, y : Resource) -> Bool

    Resource::resource_parameter

    source
    fn Resource::resource_parameter(self : Resource) -> Field[ReadOnlyArray[ResourceParameter]]

    Resource::to_repr

    source

    ResourceAssignmentExpression

    source
    pub struct ResourceAssignmentExpression {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tResourceAssignmentExpression.

    ResourceAssignmentExpression::documentation

    source

    ResourceAssignmentExpression::equal

    source

    ResourceAssignmentExpression::expression

    source

    ResourceAssignmentExpression::extension_elements

    source

    ResourceAssignmentExpression::from_element

    source

    ResourceAssignmentExpression::id

    source

    ResourceAssignmentExpression::new

    source

    ResourceAssignmentExpression::not_equal

    source

    ResourceAssignmentExpression::to_repr

    source

    ResourceParameter

    source
    pub struct ResourceParameter {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tResourceParameter.

    ResourceParameter::documentation

    source
    fn ResourceParameter::documentation(self : ResourceParameter) -> Field[ReadOnlyArray[Documentation]]

    ResourceParameter::equal

    source

    ResourceParameter::extension_elements

    source
    fn ResourceParameter::extension_elements(self : ResourceParameter) -> Field[ExtensionElements]

    ResourceParameter::from_element

    source
    fn ResourceParameter::from_element(element : Element) -> ResourceParameter?

    ResourceParameter::id

    source
    fn ResourceParameter::id(self : ResourceParameter) -> Field[String]

    ResourceParameter::is_required

    source
    fn ResourceParameter::is_required(self : ResourceParameter) -> Field[Bool]

    ResourceParameter::name

    source
    fn ResourceParameter::name(self : ResourceParameter) -> Field[String]

    ResourceParameter::new

    source
    fn ResourceParameter::new(id? : String, name? : String, type_? : Reference, is_required? : Bool, contents? : ArrayView[Content]) -> ResourceParameter

    ResourceParameter::not_equal

    source
    fn ResourceParameter::not_equal(x : ResourceParameter, y : ResourceParameter) -> Bool

    ResourceParameter::to_repr

    source

    ResourceParameter::type_

    source

    ResourceParameterBinding

    source
    pub struct ResourceParameterBinding {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tResourceParameterBinding.

    ResourceParameterBinding::documentation

    source
    fn ResourceParameterBinding::documentation(self : ResourceParameterBinding) -> Field[ReadOnlyArray[Documentation]]

    ResourceParameterBinding::equal

    source

    ResourceParameterBinding::expression

    source

    ResourceParameterBinding::extension_elements

    source

    ResourceParameterBinding::from_element

    source

    ResourceParameterBinding::id

    source

    ResourceParameterBinding::new

    source
    fn ResourceParameterBinding::new(id? : String, parameter_ref? : Reference, contents? : ArrayView[Content]) -> ResourceParameterBinding

    ResourceParameterBinding::not_equal

    source

    ResourceParameterBinding::parameter_ref

    source

    ResourceParameterBinding::to_repr

    source

    ResourceRole

    source
    pub struct ResourceRole {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tResourceRole.

    ResourceRole::documentation

    source
    fn ResourceRole::documentation(self : ResourceRole) -> Field[ReadOnlyArray[Documentation]]

    ResourceRole::equal

    source

    ResourceRole::extension_elements

    source
    fn ResourceRole::extension_elements(self : ResourceRole) -> Field[ExtensionElements]

    ResourceRole::from_element

    source
    fn ResourceRole::from_element(element : Element) -> ResourceRole?

    ResourceRole::id

    source
    fn ResourceRole::id(self : ResourceRole) -> Field[String]

    ResourceRole::name

    source
    fn ResourceRole::name(self : ResourceRole) -> Field[String]

    ResourceRole::new

    source
    fn ResourceRole::new(id? : String, name? : String, contents? : ArrayView[Content]) -> ResourceRole

    ResourceRole::not_equal

    source
    fn ResourceRole::not_equal(x : ResourceRole, y : ResourceRole) -> Bool

    ResourceRole::resource_assignment_expression

    source
    fn ResourceRole::resource_assignment_expression(self : ResourceRole) -> Field[ResourceAssignmentExpression]

    ResourceRole::resource_parameter_binding

    source
    fn ResourceRole::resource_parameter_binding(self : ResourceRole) -> Field[ReadOnlyArray[ResourceParameterBinding]]

    ResourceRole::resource_ref

    source
    fn ResourceRole::resource_ref(self : ResourceRole) -> Field[Reference]

    ResourceRole::to_repr

    source

    ResourceSet

    source
    pub struct ResourceSet {
      documents : ReadOnlyArray[DocumentResource]
      external : ReadOnlyArray[ExternalResource]
    } derive(Eq, 
    Debug    )

    Literal import-location keys are supplied by the caller. No relative-path, URL, filesystem, environment or network resolution is implicit.

    ResourceSet::equal

    source
    fn ResourceSet::equal(ResourceSet, ResourceSet) -> Bool

    ResourceSet::new

    source

    ResourceSet::not_equal

    source
    fn ResourceSet::not_equal(x : ResourceSet, y : ResourceSet) -> Bool

    ResourceSet::to_repr

    source

    RootElement

    source
    pub struct RootElement {
      element : Element
    } derive(Eq, 
    Debug    )

    RootElement::base

    source
    fn RootElement::base(self : RootElement) -> BaseElement

    RootElement::equal

    source
    fn RootElement::equal(RootElement, RootElement) -> Bool

    RootElement::from_element

    source
    fn RootElement::from_element(element : Element) -> RootElement?

    RootElement::not_equal

    source
    fn RootElement::not_equal(x : RootElement, y : RootElement) -> Bool

    RootElement::to_repr

    source

    RouteResult

    source
    pub(all) enum RouteResult {
      Found(GraphRoute)
      Unreachable
      Failed(GraphFailure)
    } derive(Eq, 
    Debug    )

    RouteResult::equal

    source
    fn RouteResult::equal(RouteResult, RouteResult) -> Bool

    RouteResult::not_equal

    source
    fn RouteResult::not_equal(x : RouteResult, y : RouteResult) -> Bool

    RouteResult::to_repr

    source

    Scalar

    source
    pub(all) enum Scalar {
      Text(String)
      Identifier(String)
      Uri(String)
      Boolean(Bool)
      Integer(ExactInteger)
      Number(ExactNumber)
      Reference(Reference)
      Enumeration(BpmnEnum)
      Invalid(raw~ : String, expected~ : ExpandedName)
    } derive(Eq, 
    Debug    )

    Invalid scalar spellings remain explicit values for inspection. Writers return a structured failure instead of serializing them as valid fields.

    Scalar::equal

    source
    fn Scalar::equal(Scalar, Scalar) -> Bool

    Scalar::not_equal

    source
    fn Scalar::not_equal(x : Scalar, y : Scalar) -> Bool

    Scalar::to_repr

    source

    Scalar::token

    source
    fn Scalar::token(self : Scalar) -> String

    SchemaElement

    source
    pub struct SchemaElement {
      name : ExpandedName
      value_type : ExpandedName?
      substitution_group : ExpandedName?
      abstract_element : Bool
    } derive(Eq, 
    Debug    )

    SchemaElement::equal

    source

    SchemaElement::not_equal

    source
    fn SchemaElement::not_equal(x : SchemaElement, y : SchemaElement) -> Bool

    SchemaElement::to_repr

    source

    SchemaField

    source
    pub struct SchemaField {
      owner : TypeId
      kind : SchemaFieldKind
      name : ExpandedName?
      value_type : ExpandedName?
      reference_element : ExpandedName?
      minimum : Int
      maximum : Int?
      default_value : String?
      fixed_value : String?
      group : String
      namespace_constraint : String
      source_path : String
    } derive(Eq, 
    Debug    )

    SchemaField::equal

    source
    fn SchemaField::equal(SchemaField, SchemaField) -> Bool

    SchemaField::not_equal

    source
    fn SchemaField::not_equal(x : SchemaField, y : SchemaField) -> Bool

    SchemaField::to_repr

    source

    SchemaFieldKind

    source
    pub(all) enum SchemaFieldKind {
      Attribute
      Child
      AnyAttribute
      AnyChild
    } derive(Eq, 
    Debug    )

    SchemaFieldKind::equal

    source

    SchemaFieldKind::not_equal

    source
    fn SchemaFieldKind::not_equal(x : SchemaFieldKind, y : SchemaFieldKind) -> Bool

    SchemaFieldKind::to_repr

    source

    SchemaGroup

    source
    pub struct SchemaGroup {
      owner : TypeId
      path : String
      parent : String
      choice : Bool
      minimum : Int
      maximum : Int?
    } derive(Eq, 
    Debug    )

    SchemaGroup::equal

    source
    fn SchemaGroup::equal(SchemaGroup, SchemaGroup) -> Bool

    SchemaGroup::not_equal

    source
    fn SchemaGroup::not_equal(x : SchemaGroup, y : SchemaGroup) -> Bool

    SchemaGroup::to_repr

    source

    SchemaType

    source
    pub struct SchemaType {
      id : TypeId
      name : ExpandedName
      base : ExpandedName?
      abstract_type : Bool
      mixed : Bool
      simple : Bool
      anonymous : Bool
      enum_values : ReadOnlyArray[String]
      union_members : ReadOnlyArray[ExpandedName]
    } derive(Eq, 
    Debug    )

    SchemaType::equal

    source
    fn SchemaType::equal(SchemaType, SchemaType) -> Bool

    SchemaType::fields

    source
    fn SchemaType::fields(self : SchemaType) -> ReadOnlyArray[SchemaField]

    Inherited fields are returned in base-to-derived declaration order. Choice membership stays in schema_groups instead of making every alternative required.

    SchemaType::has_mixed_content

    source
    fn SchemaType::has_mixed_content(self : SchemaType) -> Bool

    SchemaType::is_subtype_of

    source
    fn SchemaType::is_subtype_of(self : SchemaType, parent : ExpandedName) -> Bool

    SchemaType::not_equal

    source
    fn SchemaType::not_equal(x : SchemaType, y : SchemaType) -> Bool

    SchemaType::to_repr

    source

    Script

    source
    pub struct Script {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tScript.

    Script::equal

    source
    fn Script::equal(Script, Script) -> Bool

    Script::from_element

    source
    fn Script::from_element(element : Element) -> Script?

    Script::new

    source
    fn Script::new(contents? : ArrayView[Content]) -> Script

    Script::not_equal

    source
    fn Script::not_equal(x : Script, y : Script) -> Bool

    Script::to_repr

    source

    ScriptTask

    source
    pub struct ScriptTask {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tScriptTask.

    ScriptTask::auditing

    source
    fn ScriptTask::auditing(self : ScriptTask) -> Field[Auditing]

    ScriptTask::category_value_ref

    source
    fn ScriptTask::category_value_ref(self : ScriptTask) -> Field[ReadOnlyArray[Reference]]

    ScriptTask::completion_quantity

    source
    fn ScriptTask::completion_quantity(self : ScriptTask) -> Field[ExactInteger]

    ScriptTask::data_input_association

    source
    fn ScriptTask::data_input_association(self : ScriptTask) -> Field[ReadOnlyArray[DataInputAssociation]]

    ScriptTask::data_output_association

    source
    fn ScriptTask::data_output_association(self : ScriptTask) -> Field[ReadOnlyArray[DataOutputAssociation]]

    ScriptTask::default_

    source
    fn ScriptTask::default_(self : ScriptTask) -> Field[Reference]

    ScriptTask::documentation

    source
    fn ScriptTask::documentation(self : ScriptTask) -> Field[ReadOnlyArray[Documentation]]

    ScriptTask::equal

    source
    fn ScriptTask::equal(ScriptTask, ScriptTask) -> Bool

    ScriptTask::extension_elements

    source
    fn ScriptTask::extension_elements(self : ScriptTask) -> Field[ExtensionElements]

    ScriptTask::from_element

    source
    fn ScriptTask::from_element(element : Element) -> ScriptTask?

    ScriptTask::id

    source
    fn ScriptTask::id(self : ScriptTask) -> Field[String]

    ScriptTask::incoming

    source
    fn ScriptTask::incoming(self : ScriptTask) -> Field[ReadOnlyArray[Reference]]

    ScriptTask::io_specification

    source
    fn ScriptTask::io_specification(self : ScriptTask) -> Field[InputOutputSpecification]

    ScriptTask::is_for_compensation

    source
    fn ScriptTask::is_for_compensation(self : ScriptTask) -> Field[Bool]

    ScriptTask::loop_characteristics

    source
    fn ScriptTask::loop_characteristics(self : ScriptTask) -> Field[LoopCharacteristics]

    ScriptTask::monitoring

    source
    fn ScriptTask::monitoring(self : ScriptTask) -> Field[Monitoring]

    ScriptTask::name

    source
    fn ScriptTask::name(self : ScriptTask) -> Field[String]

    ScriptTask::new

    source
    fn ScriptTask::new(id? : String, name? : String, is_for_compensation? : Bool, start_quantity? : ExactInteger, completion_quantity? : ExactInteger, default_? : Reference, script_format? : String, contents? : ArrayView[Content]) -> ScriptTask

    ScriptTask::not_equal

    source
    fn ScriptTask::not_equal(x : ScriptTask, y : ScriptTask) -> Bool

    ScriptTask::outgoing

    source
    fn ScriptTask::outgoing(self : ScriptTask) -> Field[ReadOnlyArray[Reference]]

    ScriptTask::property

    source
    fn ScriptTask::property(self : ScriptTask) -> Field[ReadOnlyArray[Property]]

    ScriptTask::resource_role

    source
    fn ScriptTask::resource_role(self : ScriptTask) -> Field[ReadOnlyArray[ResourceRole]]

    ScriptTask::script

    source
    fn ScriptTask::script(self : ScriptTask) -> Field[Script]

    ScriptTask::script_format

    source
    fn ScriptTask::script_format(self : ScriptTask) -> Field[String]

    ScriptTask::start_quantity

    source
    fn ScriptTask::start_quantity(self : ScriptTask) -> Field[ExactInteger]

    ScriptTask::to_repr

    source

    SendTask

    source
    pub struct SendTask {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tSendTask.

    SendTask::auditing

    source
    fn SendTask::auditing(self : SendTask) -> Field[Auditing]

    SendTask::category_value_ref

    source
    fn SendTask::category_value_ref(self : SendTask) -> Field[ReadOnlyArray[Reference]]

    SendTask::completion_quantity

    source
    fn SendTask::completion_quantity(self : SendTask) -> Field[ExactInteger]

    SendTask::data_input_association

    source
    fn SendTask::data_input_association(self : SendTask) -> Field[ReadOnlyArray[DataInputAssociation]]

    SendTask::data_output_association

    source
    fn SendTask::data_output_association(self : SendTask) -> Field[ReadOnlyArray[DataOutputAssociation]]

    SendTask::default_

    source
    fn SendTask::default_(self : SendTask) -> Field[Reference]

    SendTask::documentation

    source
    fn SendTask::documentation(self : SendTask) -> Field[ReadOnlyArray[Documentation]]

    SendTask::equal

    source
    fn SendTask::equal(SendTask, SendTask) -> Bool

    SendTask::extension_elements

    source
    fn SendTask::extension_elements(self : SendTask) -> Field[ExtensionElements]

    SendTask::from_element

    source
    fn SendTask::from_element(element : Element) -> SendTask?

    SendTask::id

    source
    fn SendTask::id(self : SendTask) -> Field[String]

    SendTask::implementation

    source
    fn SendTask::implementation(self : SendTask) -> Field[Implementation]

    SendTask::incoming

    source
    fn SendTask::incoming(self : SendTask) -> Field[ReadOnlyArray[Reference]]

    SendTask::io_specification

    source
    fn SendTask::io_specification(self : SendTask) -> Field[InputOutputSpecification]

    SendTask::is_for_compensation

    source
    fn SendTask::is_for_compensation(self : SendTask) -> Field[Bool]

    SendTask::loop_characteristics

    source
    fn SendTask::loop_characteristics(self : SendTask) -> Field[LoopCharacteristics]

    SendTask::message_ref

    source
    fn SendTask::message_ref(self : SendTask) -> Field[Reference]

    SendTask::monitoring

    source
    fn SendTask::monitoring(self : SendTask) -> Field[Monitoring]

    SendTask::name

    source
    fn SendTask::name(self : SendTask) -> Field[String]

    SendTask::new

    source
    fn SendTask::new(id? : String, name? : String, is_for_compensation? : Bool, start_quantity? : ExactInteger, completion_quantity? : ExactInteger, default_? : Reference, implementation? : Implementation, message_ref? : Reference, operation_ref? : Reference, contents? : ArrayView[Content]) -> SendTask

    SendTask::not_equal

    source
    fn SendTask::not_equal(x : SendTask, y : SendTask) -> Bool

    SendTask::operation_ref

    source
    fn SendTask::operation_ref(self : SendTask) -> Field[Reference]

    SendTask::outgoing

    source
    fn SendTask::outgoing(self : SendTask) -> Field[ReadOnlyArray[Reference]]

    SendTask::property

    source
    fn SendTask::property(self : SendTask) -> Field[ReadOnlyArray[Property]]

    SendTask::resource_role

    source
    fn SendTask::resource_role(self : SendTask) -> Field[ReadOnlyArray[ResourceRole]]

    SendTask::start_quantity

    source
    fn SendTask::start_quantity(self : SendTask) -> Field[ExactInteger]

    SendTask::to_repr

    source

    SequenceFlow

    source
    pub struct SequenceFlow {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tSequenceFlow.

    SequenceFlow::auditing

    source
    fn SequenceFlow::auditing(self : SequenceFlow) -> Field[Auditing]

    SequenceFlow::category_value_ref

    source
    fn SequenceFlow::category_value_ref(self : SequenceFlow) -> Field[ReadOnlyArray[Reference]]

    SequenceFlow::condition_expression

    source
    fn SequenceFlow::condition_expression(self : SequenceFlow) -> Field[Expression]

    SequenceFlow::documentation

    source
    fn SequenceFlow::documentation(self : SequenceFlow) -> Field[ReadOnlyArray[Documentation]]

    SequenceFlow::equal

    source

    SequenceFlow::extension_elements

    source
    fn SequenceFlow::extension_elements(self : SequenceFlow) -> Field[ExtensionElements]

    SequenceFlow::from_element

    source
    fn SequenceFlow::from_element(element : Element) -> SequenceFlow?

    SequenceFlow::id

    source
    fn SequenceFlow::id(self : SequenceFlow) -> Field[String]

    SequenceFlow::is_immediate

    source
    fn SequenceFlow::is_immediate(self : SequenceFlow) -> Field[Bool]

    SequenceFlow::monitoring

    source
    fn SequenceFlow::monitoring(self : SequenceFlow) -> Field[Monitoring]

    SequenceFlow::name

    source
    fn SequenceFlow::name(self : SequenceFlow) -> Field[String]

    SequenceFlow::new

    source
    fn SequenceFlow::new(id? : String, name? : String, source_ref? : Reference, target_ref? : Reference, is_immediate? : Bool, contents? : ArrayView[Content]) -> SequenceFlow

    SequenceFlow::not_equal

    source
    fn SequenceFlow::not_equal(x : SequenceFlow, y : SequenceFlow) -> Bool

    SequenceFlow::source_ref

    source
    fn SequenceFlow::source_ref(self : SequenceFlow) -> Field[Reference]

    SequenceFlow::target_ref

    source
    fn SequenceFlow::target_ref(self : SequenceFlow) -> Field[Reference]

    SequenceFlow::to_repr

    source

    ServiceTask

    source
    pub struct ServiceTask {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tServiceTask.

    ServiceTask::auditing

    source
    fn ServiceTask::auditing(self : ServiceTask) -> Field[Auditing]

    ServiceTask::category_value_ref

    source
    fn ServiceTask::category_value_ref(self : ServiceTask) -> Field[ReadOnlyArray[Reference]]

    ServiceTask::completion_quantity

    source
    fn ServiceTask::completion_quantity(self : ServiceTask) -> Field[ExactInteger]

    ServiceTask::data_input_association

    source
    fn ServiceTask::data_input_association(self : ServiceTask) -> Field[ReadOnlyArray[DataInputAssociation]]

    ServiceTask::data_output_association

    source
    fn ServiceTask::data_output_association(self : ServiceTask) -> Field[ReadOnlyArray[DataOutputAssociation]]

    ServiceTask::default_

    source
    fn ServiceTask::default_(self : ServiceTask) -> Field[Reference]

    ServiceTask::documentation

    source
    fn ServiceTask::documentation(self : ServiceTask) -> Field[ReadOnlyArray[Documentation]]

    ServiceTask::equal

    source
    fn ServiceTask::equal(ServiceTask, ServiceTask) -> Bool

    ServiceTask::extension_elements

    source
    fn ServiceTask::extension_elements(self : ServiceTask) -> Field[ExtensionElements]

    ServiceTask::from_element

    source
    fn ServiceTask::from_element(element : Element) -> ServiceTask?

    ServiceTask::id

    source
    fn ServiceTask::id(self : ServiceTask) -> Field[String]

    ServiceTask::implementation

    source
    fn ServiceTask::implementation(self : ServiceTask) -> Field[Implementation]

    ServiceTask::incoming

    source
    fn ServiceTask::incoming(self : ServiceTask) -> Field[ReadOnlyArray[Reference]]

    ServiceTask::io_specification

    source
    fn ServiceTask::io_specification(self : ServiceTask) -> Field[InputOutputSpecification]

    ServiceTask::is_for_compensation

    source
    fn ServiceTask::is_for_compensation(self : ServiceTask) -> Field[Bool]

    ServiceTask::loop_characteristics

    source
    fn ServiceTask::loop_characteristics(self : ServiceTask) -> Field[LoopCharacteristics]

    ServiceTask::monitoring

    source
    fn ServiceTask::monitoring(self : ServiceTask) -> Field[Monitoring]

    ServiceTask::name

    source
    fn ServiceTask::name(self : ServiceTask) -> Field[String]

    ServiceTask::new

    source
    fn ServiceTask::new(id? : String, name? : String, is_for_compensation? : Bool, start_quantity? : ExactInteger, completion_quantity? : ExactInteger, default_? : Reference, implementation? : Implementation, operation_ref? : Reference, contents? : ArrayView[Content]) -> ServiceTask

    ServiceTask::not_equal

    source
    fn ServiceTask::not_equal(x : ServiceTask, y : ServiceTask) -> Bool

    ServiceTask::operation_ref

    source
    fn ServiceTask::operation_ref(self : ServiceTask) -> Field[Reference]

    ServiceTask::outgoing

    source
    fn ServiceTask::outgoing(self : ServiceTask) -> Field[ReadOnlyArray[Reference]]

    ServiceTask::property

    source
    fn ServiceTask::property(self : ServiceTask) -> Field[ReadOnlyArray[Property]]

    ServiceTask::resource_role

    source
    fn ServiceTask::resource_role(self : ServiceTask) -> Field[ReadOnlyArray[ResourceRole]]

    ServiceTask::start_quantity

    source
    fn ServiceTask::start_quantity(self : ServiceTask) -> Field[ExactInteger]

    ServiceTask::to_repr

    source

    Severity

    source
    pub(all) enum Severity {
      Error
      Warning
    } derive(Eq, 
    Debug    )

    Severity::equal

    source
    fn Severity::equal(Severity, Severity) -> Bool

    Severity::not_equal

    source
    fn Severity::not_equal(x : Severity, y : Severity) -> Bool

    Severity::to_repr

    source

    Signal

    source
    pub struct Signal {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tSignal.

    Signal::documentation

    source
    fn Signal::documentation(self : Signal) -> Field[ReadOnlyArray[Documentation]]

    Signal::equal

    source
    fn Signal::equal(Signal, Signal) -> Bool

    Signal::extension_elements

    source
    fn Signal::extension_elements(self : Signal) -> Field[ExtensionElements]

    Signal::from_element

    source
    fn Signal::from_element(element : Element) -> Signal?

    Signal::id

    source
    fn Signal::id(self : Signal) -> Field[String]

    Signal::name

    source
    fn Signal::name(self : Signal) -> Field[String]

    Signal::new

    source
    fn Signal::new(id? : String, name? : String, structure_ref? : Reference, contents? : ArrayView[Content]) -> Signal

    Signal::not_equal

    source
    fn Signal::not_equal(x : Signal, y : Signal) -> Bool

    Signal::structure_ref

    source
    fn Signal::structure_ref(self : Signal) -> Field[Reference]

    Signal::to_repr

    source

    SignalEventDefinition

    source
    pub struct SignalEventDefinition {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tSignalEventDefinition.

    SignalEventDefinition::documentation

    source
    fn SignalEventDefinition::documentation(self : SignalEventDefinition) -> Field[ReadOnlyArray[Documentation]]

    SignalEventDefinition::equal

    source

    SignalEventDefinition::extension_elements

    source

    SignalEventDefinition::from_element

    source
    fn SignalEventDefinition::from_element(element : Element) -> SignalEventDefinition?

    SignalEventDefinition::id

    source

    SignalEventDefinition::new

    source
    fn SignalEventDefinition::new(id? : String, signal_ref? : Reference, contents? : ArrayView[Content]) -> SignalEventDefinition

    SignalEventDefinition::not_equal

    source

    SignalEventDefinition::signal_ref

    source

    SignalEventDefinition::to_repr

    source

    SourceMap

    source
    pub struct SourceMap {
      source_id : String?
      length : Int
      line_starts : ReadOnlyArray[Int]
    } derive(Eq, 
    Debug    )

    SourceMap::equal

    source
    fn SourceMap::equal(SourceMap, SourceMap) -> Bool

    SourceMap::location

    source
    fn SourceMap::location(self : SourceMap, span : Span) -> Location?

    SourceMap::not_equal

    source
    fn SourceMap::not_equal(x : SourceMap, y : SourceMap) -> Bool

    SourceMap::position

    source
    fn SourceMap::position(self : SourceMap, offset : Int) -> Position?

    Offsets outside the source are rejected, not clamped into invented locations.

    SourceMap::to_repr

    source

    Span

    source
    pub struct Span {
      start : Int
      end : Int
    } derive(Eq, 
    Debug    )

    Half-open UTF-16 offsets into the owned source.

    Span::equal

    source
    fn Span::equal(Span, Span) -> Bool

    Span::not_equal

    source
    fn Span::not_equal(x : Span, y : Span) -> Bool

    Span::to_repr

    source

    StandardLoopCharacteristics

    source
    pub struct StandardLoopCharacteristics {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tStandardLoopCharacteristics.

    StandardLoopCharacteristics::documentation

    source
    fn StandardLoopCharacteristics::documentation(self : StandardLoopCharacteristics) -> Field[ReadOnlyArray[Documentation]]

    StandardLoopCharacteristics::equal

    source

    StandardLoopCharacteristics::extension_elements

    source

    StandardLoopCharacteristics::from_element

    source

    StandardLoopCharacteristics::id

    source

    StandardLoopCharacteristics::loop_condition

    source

    StandardLoopCharacteristics::loop_maximum

    source

    StandardLoopCharacteristics::new

    source
    fn StandardLoopCharacteristics::new(id? : String, test_before? : Bool, loop_maximum? : ExactInteger, contents? : ArrayView[Content]) -> StandardLoopCharacteristics

    StandardLoopCharacteristics::not_equal

    source

    StandardLoopCharacteristics::test_before

    source

    StandardLoopCharacteristics::to_repr

    source

    StartEvent

    source
    pub struct StartEvent {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tStartEvent.

    StartEvent::auditing

    source
    fn StartEvent::auditing(self : StartEvent) -> Field[Auditing]

    StartEvent::category_value_ref

    source
    fn StartEvent::category_value_ref(self : StartEvent) -> Field[ReadOnlyArray[Reference]]

    StartEvent::data_output

    source
    fn StartEvent::data_output(self : StartEvent) -> Field[ReadOnlyArray[DataOutput]]

    StartEvent::data_output_association

    source
    fn StartEvent::data_output_association(self : StartEvent) -> Field[ReadOnlyArray[DataOutputAssociation]]

    StartEvent::documentation

    source
    fn StartEvent::documentation(self : StartEvent) -> Field[ReadOnlyArray[Documentation]]

    StartEvent::equal

    source
    fn StartEvent::equal(StartEvent, StartEvent) -> Bool

    StartEvent::event_definition

    source
    fn StartEvent::event_definition(self : StartEvent) -> Field[ReadOnlyArray[EventDefinition]]

    StartEvent::event_definition_ref

    source
    fn StartEvent::event_definition_ref(self : StartEvent) -> Field[ReadOnlyArray[Reference]]

    StartEvent::extension_elements

    source
    fn StartEvent::extension_elements(self : StartEvent) -> Field[ExtensionElements]

    StartEvent::from_element

    source
    fn StartEvent::from_element(element : Element) -> StartEvent?

    StartEvent::id

    source
    fn StartEvent::id(self : StartEvent) -> Field[String]

    StartEvent::incoming

    source
    fn StartEvent::incoming(self : StartEvent) -> Field[ReadOnlyArray[Reference]]

    StartEvent::is_interrupting

    source
    fn StartEvent::is_interrupting(self : StartEvent) -> Field[Bool]

    StartEvent::monitoring

    source
    fn StartEvent::monitoring(self : StartEvent) -> Field[Monitoring]

    StartEvent::name

    source
    fn StartEvent::name(self : StartEvent) -> Field[String]

    StartEvent::new

    source
    fn StartEvent::new(id? : String, name? : String, parallel_multiple? : Bool, is_interrupting? : Bool, contents? : ArrayView[Content]) -> StartEvent

    StartEvent::not_equal

    source
    fn StartEvent::not_equal(x : StartEvent, y : StartEvent) -> Bool

    StartEvent::outgoing

    source
    fn StartEvent::outgoing(self : StartEvent) -> Field[ReadOnlyArray[Reference]]

    StartEvent::output_set

    source
    fn StartEvent::output_set(self : StartEvent) -> Field[OutputSet]

    StartEvent::parallel_multiple

    source
    fn StartEvent::parallel_multiple(self : StartEvent) -> Field[Bool]

    StartEvent::property

    source
    fn StartEvent::property(self : StartEvent) -> Field[ReadOnlyArray[Property]]

    StartEvent::to_repr

    source

    StructureResult

    source
    pub struct StructureResult {
      index : DocumentIndex
      findings : ReadOnlyArray[ValidationFinding]
      complete : Bool
    } derive(
    Debug    )

    SubChoreography

    source
    pub struct SubChoreography {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tSubChoreography.

    SubChoreography::artifact

    source
    fn SubChoreography::artifact(self : SubChoreography) -> Field[ReadOnlyArray[Artifact]]

    SubChoreography::auditing

    source

    SubChoreography::category_value_ref

    source
    fn SubChoreography::category_value_ref(self : SubChoreography) -> Field[ReadOnlyArray[Reference]]

    SubChoreography::correlation_key

    source
    fn SubChoreography::correlation_key(self : SubChoreography) -> Field[ReadOnlyArray[CorrelationKey]]

    SubChoreography::documentation

    source
    fn SubChoreography::documentation(self : SubChoreography) -> Field[ReadOnlyArray[Documentation]]

    SubChoreography::equal

    source

    SubChoreography::extension_elements

    source
    fn SubChoreography::extension_elements(self : SubChoreography) -> Field[ExtensionElements]

    SubChoreography::flow_element

    source
    fn SubChoreography::flow_element(self : SubChoreography) -> Field[ReadOnlyArray[FlowElement]]

    SubChoreography::from_element

    source
    fn SubChoreography::from_element(element : Element) -> SubChoreography?

    SubChoreography::id

    source
    fn SubChoreography::id(self : SubChoreography) -> Field[String]

    SubChoreography::incoming

    source
    fn SubChoreography::incoming(self : SubChoreography) -> Field[ReadOnlyArray[Reference]]

    SubChoreography::initiating_participant_ref

    source
    fn SubChoreography::initiating_participant_ref(self : SubChoreography) -> Field[Reference]

    SubChoreography::loop_type

    source

    SubChoreography::monitoring

    source
    fn SubChoreography::monitoring(self : SubChoreography) -> Field[Monitoring]

    SubChoreography::name

    source
    fn SubChoreography::name(self : SubChoreography) -> Field[String]

    SubChoreography::new

    source
    fn SubChoreography::new(id? : String, name? : String, initiating_participant_ref? : Reference, loop_type? : ChoreographyLoopType, contents? : ArrayView[Content]) -> SubChoreography

    SubChoreography::not_equal

    source
    fn SubChoreography::not_equal(x : SubChoreography, y : SubChoreography) -> Bool

    SubChoreography::outgoing

    source
    fn SubChoreography::outgoing(self : SubChoreography) -> Field[ReadOnlyArray[Reference]]

    SubChoreography::participant_ref

    source
    fn SubChoreography::participant_ref(self : SubChoreography) -> Field[ReadOnlyArray[Reference]]

    SubChoreography::to_repr

    source

    SubConversation

    source
    pub struct SubConversation {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tSubConversation.

    SubConversation::conversation_node

    source
    fn SubConversation::conversation_node(self : SubConversation) -> Field[ReadOnlyArray[ConversationNode]]

    SubConversation::correlation_key

    source
    fn SubConversation::correlation_key(self : SubConversation) -> Field[ReadOnlyArray[CorrelationKey]]

    SubConversation::documentation

    source
    fn SubConversation::documentation(self : SubConversation) -> Field[ReadOnlyArray[Documentation]]

    SubConversation::equal

    source

    SubConversation::extension_elements

    source
    fn SubConversation::extension_elements(self : SubConversation) -> Field[ExtensionElements]

    SubConversation::from_element

    source
    fn SubConversation::from_element(element : Element) -> SubConversation?

    SubConversation::id

    source
    fn SubConversation::id(self : SubConversation) -> Field[String]

    SubConversation::message_flow_ref

    source
    fn SubConversation::message_flow_ref(self : SubConversation) -> Field[ReadOnlyArray[Reference]]

    SubConversation::name

    source
    fn SubConversation::name(self : SubConversation) -> Field[String]

    SubConversation::new

    source
    fn SubConversation::new(id? : String, name? : String, contents? : ArrayView[Content]) -> SubConversation

    SubConversation::not_equal

    source
    fn SubConversation::not_equal(x : SubConversation, y : SubConversation) -> Bool

    SubConversation::participant_ref

    source
    fn SubConversation::participant_ref(self : SubConversation) -> Field[ReadOnlyArray[Reference]]

    SubConversation::to_repr

    source

    SubProcess

    source
    pub struct SubProcess {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tSubProcess.

    SubProcess::artifact

    source
    fn SubProcess::artifact(self : SubProcess) -> Field[ReadOnlyArray[Artifact]]

    SubProcess::auditing

    source
    fn SubProcess::auditing(self : SubProcess) -> Field[Auditing]

    SubProcess::category_value_ref

    source
    fn SubProcess::category_value_ref(self : SubProcess) -> Field[ReadOnlyArray[Reference]]

    SubProcess::completion_quantity

    source
    fn SubProcess::completion_quantity(self : SubProcess) -> Field[ExactInteger]

    SubProcess::data_input_association

    source
    fn SubProcess::data_input_association(self : SubProcess) -> Field[ReadOnlyArray[DataInputAssociation]]

    SubProcess::data_output_association

    source
    fn SubProcess::data_output_association(self : SubProcess) -> Field[ReadOnlyArray[DataOutputAssociation]]

    SubProcess::default_

    source
    fn SubProcess::default_(self : SubProcess) -> Field[Reference]

    SubProcess::documentation

    source
    fn SubProcess::documentation(self : SubProcess) -> Field[ReadOnlyArray[Documentation]]

    SubProcess::equal

    source
    fn SubProcess::equal(SubProcess, SubProcess) -> Bool

    SubProcess::extension_elements

    source
    fn SubProcess::extension_elements(self : SubProcess) -> Field[ExtensionElements]

    SubProcess::flow_element

    source
    fn SubProcess::flow_element(self : SubProcess) -> Field[ReadOnlyArray[FlowElement]]

    SubProcess::from_element

    source
    fn SubProcess::from_element(element : Element) -> SubProcess?

    SubProcess::id

    source
    fn SubProcess::id(self : SubProcess) -> Field[String]

    SubProcess::incoming

    source
    fn SubProcess::incoming(self : SubProcess) -> Field[ReadOnlyArray[Reference]]

    SubProcess::io_specification

    source
    fn SubProcess::io_specification(self : SubProcess) -> Field[InputOutputSpecification]

    SubProcess::is_for_compensation

    source
    fn SubProcess::is_for_compensation(self : SubProcess) -> Field[Bool]

    SubProcess::lane_set

    source
    fn SubProcess::lane_set(self : SubProcess) -> Field[ReadOnlyArray[LaneSet]]

    SubProcess::loop_characteristics

    source
    fn SubProcess::loop_characteristics(self : SubProcess) -> Field[LoopCharacteristics]

    SubProcess::monitoring

    source
    fn SubProcess::monitoring(self : SubProcess) -> Field[Monitoring]

    SubProcess::name

    source
    fn SubProcess::name(self : SubProcess) -> Field[String]

    SubProcess::new

    source
    fn SubProcess::new(id? : String, name? : String, is_for_compensation? : Bool, start_quantity? : ExactInteger, completion_quantity? : ExactInteger, default_? : Reference, triggered_by_event? : Bool, contents? : ArrayView[Content]) -> SubProcess

    SubProcess::not_equal

    source
    fn SubProcess::not_equal(x : SubProcess, y : SubProcess) -> Bool

    SubProcess::outgoing

    source
    fn SubProcess::outgoing(self : SubProcess) -> Field[ReadOnlyArray[Reference]]

    SubProcess::property

    source
    fn SubProcess::property(self : SubProcess) -> Field[ReadOnlyArray[Property]]

    SubProcess::resource_role

    source
    fn SubProcess::resource_role(self : SubProcess) -> Field[ReadOnlyArray[ResourceRole]]

    SubProcess::start_quantity

    source
    fn SubProcess::start_quantity(self : SubProcess) -> Field[ExactInteger]

    SubProcess::to_repr

    source

    SubProcess::triggered_by_event

    source
    fn SubProcess::triggered_by_event(self : SubProcess) -> Field[Bool]

    Task

    source
    pub struct Task {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tTask.

    Task::auditing

    source
    fn Task::auditing(self : Task) -> Field[Auditing]

    Task::category_value_ref

    source
    fn Task::category_value_ref(self : Task) -> Field[ReadOnlyArray[Reference]]

    Task::completion_quantity

    source
    fn Task::completion_quantity(self : Task) -> Field[ExactInteger]

    Task::data_input_association

    source
    fn Task::data_input_association(self : Task) -> Field[ReadOnlyArray[DataInputAssociation]]

    Task::data_output_association

    source
    fn Task::data_output_association(self : Task) -> Field[ReadOnlyArray[DataOutputAssociation]]

    Task::default_

    source
    fn Task::default_(self : Task) -> Field[Reference]

    Task::documentation

    source
    fn Task::documentation(self : Task) -> Field[ReadOnlyArray[Documentation]]

    Task::equal

    source
    fn Task::equal(Task, Task) -> Bool

    Task::extension_elements

    source
    fn Task::extension_elements(self : Task) -> Field[ExtensionElements]

    Task::from_element

    source
    fn Task::from_element(element : Element) -> Task?

    Task::id

    source
    fn Task::id(self : Task) -> Field[String]

    Task::incoming

    source
    fn Task::incoming(self : Task) -> Field[ReadOnlyArray[Reference]]

    Task::io_specification

    source
    fn Task::io_specification(self : Task) -> Field[InputOutputSpecification]

    Task::is_for_compensation

    source
    fn Task::is_for_compensation(self : Task) -> Field[Bool]

    Task::loop_characteristics

    source
    fn Task::loop_characteristics(self : Task) -> Field[LoopCharacteristics]

    Task::monitoring

    source
    fn Task::monitoring(self : Task) -> Field[Monitoring]

    Task::name

    source
    fn Task::name(self : Task) -> Field[String]

    Task::new

    source
    fn Task::new(id? : String, name? : String, is_for_compensation? : Bool, start_quantity? : ExactInteger, completion_quantity? : ExactInteger, default_? : Reference, contents? : ArrayView[Content]) -> Task

    Task::not_equal

    source
    fn Task::not_equal(x : Task, y : Task) -> Bool

    Task::outgoing

    source
    fn Task::outgoing(self : Task) -> Field[ReadOnlyArray[Reference]]

    Task::property

    source
    fn Task::property(self : Task) -> Field[ReadOnlyArray[Property]]

    Task::resource_role

    source
    fn Task::resource_role(self : Task) -> Field[ReadOnlyArray[ResourceRole]]

    Task::start_quantity

    source
    fn Task::start_quantity(self : Task) -> Field[ExactInteger]

    Task::to_repr

    source

    TerminateEventDefinition

    source
    pub struct TerminateEventDefinition {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tTerminateEventDefinition.

    TerminateEventDefinition::documentation

    source
    fn TerminateEventDefinition::documentation(self : TerminateEventDefinition) -> Field[ReadOnlyArray[Documentation]]

    TerminateEventDefinition::equal

    source

    TerminateEventDefinition::extension_elements

    source

    TerminateEventDefinition::from_element

    source

    TerminateEventDefinition::id

    source

    TerminateEventDefinition::new

    source

    TerminateEventDefinition::not_equal

    source

    TerminateEventDefinition::to_repr

    source

    Text

    source
    pub struct Text {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tText.

    Text::equal

    source
    fn Text::equal(Text, Text) -> Bool

    Text::from_element

    source
    fn Text::from_element(element : Element) -> Text?

    Text::new

    source
    fn Text::new(contents? : ArrayView[Content]) -> Text

    Text::not_equal

    source
    fn Text::not_equal(x : Text, y : Text) -> Bool

    Text::to_repr

    source

    TextAnnotation

    source
    pub struct TextAnnotation {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tTextAnnotation.

    TextAnnotation::documentation

    source
    fn TextAnnotation::documentation(self : TextAnnotation) -> Field[ReadOnlyArray[Documentation]]

    TextAnnotation::equal

    source

    TextAnnotation::extension_elements

    source
    fn TextAnnotation::extension_elements(self : TextAnnotation) -> Field[ExtensionElements]

    TextAnnotation::from_element

    source
    fn TextAnnotation::from_element(element : Element) -> TextAnnotation?

    TextAnnotation::id

    source
    fn TextAnnotation::id(self : TextAnnotation) -> Field[String]

    TextAnnotation::new

    source
    fn TextAnnotation::new(id? : String, text_format? : String, contents? : ArrayView[Content]) -> TextAnnotation

    TextAnnotation::not_equal

    source
    fn TextAnnotation::not_equal(x : TextAnnotation, y : TextAnnotation) -> Bool

    TextAnnotation::text

    source

    TextAnnotation::text_format

    source
    fn TextAnnotation::text_format(self : TextAnnotation) -> Field[String]

    TextAnnotation::to_repr

    source

    ThrowEvent

    source
    pub struct ThrowEvent {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tThrowEvent.

    ThrowEvent::auditing

    source
    fn ThrowEvent::auditing(self : ThrowEvent) -> Field[Auditing]

    ThrowEvent::category_value_ref

    source
    fn ThrowEvent::category_value_ref(self : ThrowEvent) -> Field[ReadOnlyArray[Reference]]

    ThrowEvent::data_input

    source
    fn ThrowEvent::data_input(self : ThrowEvent) -> Field[ReadOnlyArray[DataInput]]

    ThrowEvent::data_input_association

    source
    fn ThrowEvent::data_input_association(self : ThrowEvent) -> Field[ReadOnlyArray[DataInputAssociation]]

    ThrowEvent::documentation

    source
    fn ThrowEvent::documentation(self : ThrowEvent) -> Field[ReadOnlyArray[Documentation]]

    ThrowEvent::equal

    source
    fn ThrowEvent::equal(ThrowEvent, ThrowEvent) -> Bool

    ThrowEvent::event_definition

    source
    fn ThrowEvent::event_definition(self : ThrowEvent) -> Field[ReadOnlyArray[EventDefinition]]

    ThrowEvent::event_definition_ref

    source
    fn ThrowEvent::event_definition_ref(self : ThrowEvent) -> Field[ReadOnlyArray[Reference]]

    ThrowEvent::extension_elements

    source
    fn ThrowEvent::extension_elements(self : ThrowEvent) -> Field[ExtensionElements]

    ThrowEvent::from_element

    source
    fn ThrowEvent::from_element(element : Element) -> ThrowEvent?

    ThrowEvent::id

    source
    fn ThrowEvent::id(self : ThrowEvent) -> Field[String]

    ThrowEvent::incoming

    source
    fn ThrowEvent::incoming(self : ThrowEvent) -> Field[ReadOnlyArray[Reference]]

    ThrowEvent::input_set

    source
    fn ThrowEvent::input_set(self : ThrowEvent) -> Field[InputSet]

    ThrowEvent::monitoring

    source
    fn ThrowEvent::monitoring(self : ThrowEvent) -> Field[Monitoring]

    ThrowEvent::name

    source
    fn ThrowEvent::name(self : ThrowEvent) -> Field[String]

    ThrowEvent::not_equal

    source
    fn ThrowEvent::not_equal(x : ThrowEvent, y : ThrowEvent) -> Bool

    ThrowEvent::outgoing

    source
    fn ThrowEvent::outgoing(self : ThrowEvent) -> Field[ReadOnlyArray[Reference]]

    ThrowEvent::property

    source
    fn ThrowEvent::property(self : ThrowEvent) -> Field[ReadOnlyArray[Property]]

    ThrowEvent::to_repr

    source

    TimerEventDefinition

    source
    pub struct TimerEventDefinition {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tTimerEventDefinition.

    TimerEventDefinition::documentation

    source
    fn TimerEventDefinition::documentation(self : TimerEventDefinition) -> Field[ReadOnlyArray[Documentation]]

    TimerEventDefinition::equal

    source

    TimerEventDefinition::extension_elements

    source

    TimerEventDefinition::from_element

    source
    fn TimerEventDefinition::from_element(element : Element) -> TimerEventDefinition?

    TimerEventDefinition::id

    source

    TimerEventDefinition::new

    source
    fn TimerEventDefinition::new(id? : String, contents? : ArrayView[Content]) -> TimerEventDefinition

    TimerEventDefinition::not_equal

    source

    TimerEventDefinition::time_cycle

    source

    TimerEventDefinition::time_date

    source

    TimerEventDefinition::time_duration

    source

    TimerEventDefinition::to_repr

    source

    Token

    source
    pub struct Token {
      kind : TokenKind
      text : String
      span : Span
    } derive(Eq, 
    Debug    )

    Token::equal

    source
    fn Token::equal(Token, Token) -> Bool

    Token::not_equal

    source
    fn Token::not_equal(x : Token, y : Token) -> Bool

    Token::to_repr

    source

    TokenKind

    source
    pub(all) enum TokenKind {
      Open
      EndOpen
      Close
      EmptyClose
      Name
      Whitespace
      Equals
      Quote
      AttributeValue
      Text
      CharacterReference
      Comment
      ProcessingInstruction
      CData
      Declaration
      Error
    } derive(Eq, 
    Debug    )

    Lexical source records. Raw text is never normalized or entity-expanded.

    TokenKind::equal

    source
    fn TokenKind::equal(TokenKind, TokenKind) -> Bool

    TokenKind::not_equal

    source
    fn TokenKind::not_equal(x : TokenKind, y : TokenKind) -> Bool

    TokenKind::to_repr

    source

    Transaction

    source
    pub struct Transaction {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tTransaction.

    Transaction::artifact

    source
    fn Transaction::artifact(self : Transaction) -> Field[ReadOnlyArray[Artifact]]

    Transaction::auditing

    source
    fn Transaction::auditing(self : Transaction) -> Field[Auditing]

    Transaction::category_value_ref

    source
    fn Transaction::category_value_ref(self : Transaction) -> Field[ReadOnlyArray[Reference]]

    Transaction::completion_quantity

    source
    fn Transaction::completion_quantity(self : Transaction) -> Field[ExactInteger]

    Transaction::data_input_association

    source
    fn Transaction::data_input_association(self : Transaction) -> Field[ReadOnlyArray[DataInputAssociation]]

    Transaction::data_output_association

    source
    fn Transaction::data_output_association(self : Transaction) -> Field[ReadOnlyArray[DataOutputAssociation]]

    Transaction::default_

    source
    fn Transaction::default_(self : Transaction) -> Field[Reference]

    Transaction::documentation

    source
    fn Transaction::documentation(self : Transaction) -> Field[ReadOnlyArray[Documentation]]

    Transaction::equal

    source
    fn Transaction::equal(Transaction, Transaction) -> Bool

    Transaction::extension_elements

    source
    fn Transaction::extension_elements(self : Transaction) -> Field[ExtensionElements]

    Transaction::flow_element

    source
    fn Transaction::flow_element(self : Transaction) -> Field[ReadOnlyArray[FlowElement]]

    Transaction::from_element

    source
    fn Transaction::from_element(element : Element) -> Transaction?

    Transaction::id

    source
    fn Transaction::id(self : Transaction) -> Field[String]

    Transaction::incoming

    source
    fn Transaction::incoming(self : Transaction) -> Field[ReadOnlyArray[Reference]]

    Transaction::io_specification

    source
    fn Transaction::io_specification(self : Transaction) -> Field[InputOutputSpecification]

    Transaction::is_for_compensation

    source
    fn Transaction::is_for_compensation(self : Transaction) -> Field[Bool]

    Transaction::lane_set

    source
    fn Transaction::lane_set(self : Transaction) -> Field[ReadOnlyArray[LaneSet]]

    Transaction::loop_characteristics

    source
    fn Transaction::loop_characteristics(self : Transaction) -> Field[LoopCharacteristics]

    Transaction::method_

    source

    Transaction::monitoring

    source
    fn Transaction::monitoring(self : Transaction) -> Field[Monitoring]

    Transaction::name

    source
    fn Transaction::name(self : Transaction) -> Field[String]

    Transaction::new

    source
    fn Transaction::new(id? : String, name? : String, is_for_compensation? : Bool, start_quantity? : ExactInteger, completion_quantity? : ExactInteger, default_? : Reference, triggered_by_event? : Bool, method_? : TransactionMethod, contents? : ArrayView[Content]) -> Transaction

    Transaction::not_equal

    source
    fn Transaction::not_equal(x : Transaction, y : Transaction) -> Bool

    Transaction::outgoing

    source
    fn Transaction::outgoing(self : Transaction) -> Field[ReadOnlyArray[Reference]]

    Transaction::property

    source
    fn Transaction::property(self : Transaction) -> Field[ReadOnlyArray[Property]]

    Transaction::resource_role

    source
    fn Transaction::resource_role(self : Transaction) -> Field[ReadOnlyArray[ResourceRole]]

    Transaction::start_quantity

    source
    fn Transaction::start_quantity(self : Transaction) -> Field[ExactInteger]

    Transaction::to_repr

    source

    Transaction::triggered_by_event

    source
    fn Transaction::triggered_by_event(self : Transaction) -> Field[Bool]

    TransactionMethod

    source
    pub(all) enum TransactionMethod {
      Compensate
      Image
      Store
      Uri(String)
    } derive(Eq, 
    Debug    )

    Values of the pinned XSD type tTransactionMethod.

    TransactionMethod::equal

    source

    TransactionMethod::not_equal

    source
    fn TransactionMethod::not_equal(x : TransactionMethod, y : TransactionMethod) -> Bool

    TransactionMethod::parse

    source
    fn TransactionMethod::parse(token : String) -> TransactionMethod?

    TransactionMethod::to_repr

    source

    TransactionMethod::token

    source
    fn TransactionMethod::token(self : TransactionMethod) -> String

    TraversalEvent

    source
    pub(all) enum TraversalEvent {
      Enter(NodeRef)
      Leave(NodeRef)
    } derive(Eq, 
    Debug    )

    TraversalEvent::equal

    source

    TraversalEvent::not_equal

    source
    fn TraversalEvent::not_equal(x : TraversalEvent, y : TraversalEvent) -> Bool

    TraversalEvent::to_repr

    source

    TreeBuildResult

    source
    pub struct TreeBuildResult {
      tree : DocumentTree?
      diagnostics : ReadOnlyArray[Diagnostic]
    } derive(
    Debug    )

    TreeCursor

    source
    pub struct TreeCursor {
      // private fields
    }

    TreeCursor::depth

    source
    fn TreeCursor::depth(self : TreeCursor) -> Int

    TreeCursor::goto_first_child

    source
    fn TreeCursor::goto_first_child(self : TreeCursor) -> Bool

    TreeCursor::goto_last_child

    source
    fn TreeCursor::goto_last_child(self : TreeCursor) -> Bool

    TreeCursor::goto_next_sibling

    source
    fn TreeCursor::goto_next_sibling(self : TreeCursor) -> Bool

    TreeCursor::goto_parent

    source
    fn TreeCursor::goto_parent(self : TreeCursor) -> Bool

    TreeCursor::goto_previous_sibling

    source
    fn TreeCursor::goto_previous_sibling(self : TreeCursor) -> Bool

    TreeCursor::new

    source
    fn TreeCursor::new(root : NodeRef) -> TreeCursor

    TreeCursor::node

    source
    fn TreeCursor::node(self : TreeCursor) -> NodeRef

    TreeCursor::path

    source
    fn TreeCursor::path(self : TreeCursor) -> NodePath

    TypeId

    source
    pub(all) enum TypeId {
      Definitions
      Import
      BpmnBPMNDiagram
      BpmnBPMNPlane
      BpmnBPMNEdge
      BpmnBPMNShape
      BpmnBPMNLabel
      BpmnBPMNLabelStyle
      BpmnParticipantBandKind
      BpmnMessageVisibleKind
      DcFont
      DcPoint
      DcBounds
      DiDiagramElement
      DiAnonymousDiagramElementExtension1
      DiDiagram
      DiNode
      DiEdge
      DiLabeledEdge
      DiShape
      DiLabeledShape
      DiLabel
      DiPlane
      DiStyle
      Activity
      AdHocSubProcess
      AdHocOrdering
      Artifact
      Assignment
      Association
      AssociationDirection
      Auditing
      BaseElement
      BaseElementWithMixedContent
      BoundaryEvent
      BusinessRuleTask
      CallableElement
      CallActivity
      CallChoreography
      CallConversation
      CancelEventDefinition
      CatchEvent
      Category
      CategoryValue
      Choreography
      ChoreographyActivity
      ChoreographyLoopType
      ChoreographyTask
      Collaboration
      CompensateEventDefinition
      ComplexBehaviorDefinition
      ComplexGateway
      ConditionalEventDefinition
      Conversation
      ConversationAssociation
      ConversationLink
      ConversationNode
      CorrelationKey
      CorrelationProperty
      CorrelationPropertyBinding
      CorrelationPropertyRetrievalExpression
      CorrelationSubscription
      DataAssociation
      DataInput
      DataInputAssociation
      DataObject
      DataObjectReference
      DataOutput
      DataOutputAssociation
      DataState
      DataStore
      DataStoreReference
      Documentation
      EndEvent
      EndPoint
      Error
      ErrorEventDefinition
      Escalation
      EscalationEventDefinition
      Event
      EventBasedGateway
      EventBasedGatewayType
      EventDefinition
      ExclusiveGateway
      Expression
      Extension
      ExtensionElements
      FlowElement
      FlowNode
      FormalExpression
      Gateway
      GatewayDirection
      GlobalBusinessRuleTask
      GlobalChoreographyTask
      GlobalConversation
      GlobalManualTask
      GlobalScriptTask
      GlobalTask
      GlobalUserTask
      Group
      HumanPerformer
      Implementation
      AnonymousTImplementation78
      ImplicitThrowEvent
      InclusiveGateway
      InputSet
      Interface
      IntermediateCatchEvent
      IntermediateThrowEvent
      InputOutputBinding
      InputOutputSpecification
      ItemDefinition
      ItemKind
      Lane
      LaneSet
      LinkEventDefinition
      LoopCharacteristics
      ManualTask
      Message
      MessageEventDefinition
      MessageFlow
      MessageFlowAssociation
      Monitoring
      MultiInstanceLoopCharacteristics
      MultiInstanceFlowCondition
      Operation
      OutputSet
      ParallelGateway
      Participant
      ParticipantAssociation
      ParticipantMultiplicity
      PartnerEntity
      PartnerRole
      Performer
      PotentialOwner
      Process
      ProcessType
      Property
      ReceiveTask
      Relationship
      RelationshipDirection
      Rendering
      Resource
      ResourceAssignmentExpression
      ResourceParameter
      ResourceParameterBinding
      ResourceRole
      RootElement
      ScriptTask
      Script
      SendTask
      SequenceFlow
      ServiceTask
      Signal
      SignalEventDefinition
      StandardLoopCharacteristics
      StartEvent
      SubChoreography
      SubConversation
      SubProcess
      Task
      TerminateEventDefinition
      TextAnnotation
      Text
      ThrowEvent
      TimerEventDefinition
      Transaction
      TransactionMethod
      AnonymousTTransactionMethod144
      UserTask
    } derive(Eq, 
    Debug    )

    TypeId::equal

    source
    fn TypeId::equal(TypeId, TypeId) -> Bool

    TypeId::name

    source
    fn TypeId::name(self : TypeId) -> ExpandedName

    TypeId::not_equal

    source
    fn TypeId::not_equal(x : TypeId, y : TypeId) -> Bool

    TypeId::to_repr

    source

    UserTask

    source
    pub struct UserTask {
      element : Element
    } derive(Eq, 
    Debug    )

    Immutable typed view of schema tUserTask.

    UserTask::auditing

    source
    fn UserTask::auditing(self : UserTask) -> Field[Auditing]

    UserTask::category_value_ref

    source
    fn UserTask::category_value_ref(self : UserTask) -> Field[ReadOnlyArray[Reference]]

    UserTask::completion_quantity

    source
    fn UserTask::completion_quantity(self : UserTask) -> Field[ExactInteger]

    UserTask::data_input_association

    source
    fn UserTask::data_input_association(self : UserTask) -> Field[ReadOnlyArray[DataInputAssociation]]

    UserTask::data_output_association

    source
    fn UserTask::data_output_association(self : UserTask) -> Field[ReadOnlyArray[DataOutputAssociation]]

    UserTask::default_

    source
    fn UserTask::default_(self : UserTask) -> Field[Reference]

    UserTask::documentation

    source
    fn UserTask::documentation(self : UserTask) -> Field[ReadOnlyArray[Documentation]]

    UserTask::equal

    source
    fn UserTask::equal(UserTask, UserTask) -> Bool

    UserTask::extension_elements

    source
    fn UserTask::extension_elements(self : UserTask) -> Field[ExtensionElements]

    UserTask::from_element

    source
    fn UserTask::from_element(element : Element) -> UserTask?

    UserTask::id

    source
    fn UserTask::id(self : UserTask) -> Field[String]

    UserTask::implementation

    source
    fn UserTask::implementation(self : UserTask) -> Field[Implementation]

    UserTask::incoming

    source
    fn UserTask::incoming(self : UserTask) -> Field[ReadOnlyArray[Reference]]

    UserTask::io_specification

    source
    fn UserTask::io_specification(self : UserTask) -> Field[InputOutputSpecification]

    UserTask::is_for_compensation

    source
    fn UserTask::is_for_compensation(self : UserTask) -> Field[Bool]

    UserTask::loop_characteristics

    source
    fn UserTask::loop_characteristics(self : UserTask) -> Field[LoopCharacteristics]

    UserTask::monitoring

    source
    fn UserTask::monitoring(self : UserTask) -> Field[Monitoring]

    UserTask::name

    source
    fn UserTask::name(self : UserTask) -> Field[String]

    UserTask::new

    source
    fn UserTask::new(id? : String, name? : String, is_for_compensation? : Bool, start_quantity? : ExactInteger, completion_quantity? : ExactInteger, default_? : Reference, implementation? : Implementation, contents? : ArrayView[Content]) -> UserTask

    UserTask::not_equal

    source
    fn UserTask::not_equal(x : UserTask, y : UserTask) -> Bool

    UserTask::outgoing

    source
    fn UserTask::outgoing(self : UserTask) -> Field[ReadOnlyArray[Reference]]

    UserTask::property

    source
    fn UserTask::property(self : UserTask) -> Field[ReadOnlyArray[Property]]

    UserTask::rendering

    source
    fn UserTask::rendering(self : UserTask) -> Field[ReadOnlyArray[Rendering]]

    UserTask::resource_role

    source
    fn UserTask::resource_role(self : UserTask) -> Field[ReadOnlyArray[ResourceRole]]

    UserTask::start_quantity

    source
    fn UserTask::start_quantity(self : UserTask) -> Field[ExactInteger]

    UserTask::to_repr

    source

    ValidationFinding

    source
    pub struct ValidationFinding {
      stage : ValidationStage
      diagnostic : Diagnostic
      resource_id : String?
      node : Int?
      element_id : String?
      field : ExpandedName?
    } derive(Eq, 
    Debug    )

    The node ordinal is local to the result's index. It is not a revision handle.

    ValidationFinding::equal

    source

    ValidationFinding::not_equal

    source
    fn ValidationFinding::not_equal(x : ValidationFinding, y : ValidationFinding) -> Bool

    ValidationFinding::to_repr

    source

    ValidationResult

    source
    pub struct ValidationResult {
      document : Document?
      index : DocumentIndex?
      references : ReadOnlyArray[ResolvedReference]
      findings : ReadOnlyArray[ValidationFinding]
      complete : Bool
    } derive(
    Debug    )

    ValidationStage

    source
    pub(all) enum ValidationStage {
      Syntax
      Structure
      References
    } derive(Eq, 
    Debug    )

    ValidationStage::equal

    source

    ValidationStage::not_equal

    source
    fn ValidationStage::not_equal(x : ValidationStage, y : ValidationStage) -> Bool

    ValidationStage::to_repr

    source

    WriteFormat

    source
    pub(all) enum WriteFormat {
      Compact
      Pretty
    } derive(Eq, 
    Debug    )

    WriteFormat::equal

    source
    fn WriteFormat::equal(WriteFormat, WriteFormat) -> Bool

    WriteFormat::not_equal

    source
    fn WriteFormat::not_equal(x : WriteFormat, y : WriteFormat) -> Bool

    WriteFormat::to_repr

    source

    WriteResult

    source
    pub struct WriteResult {
      output : String?
      diagnostics : ReadOnlyArray[Diagnostic]
    } derive(Eq, 
    Debug    )

    WriteResult::equal

    source
    fn WriteResult::equal(WriteResult, WriteResult) -> Bool

    WriteResult::not_equal

    source
    fn WriteResult::not_equal(x : WriteResult, y : WriteResult) -> Bool

    WriteResult::to_repr

    source

    XmlAttribute

    source
    pub struct XmlAttribute {
      raw_name : String
      name : ExpandedName
      value : String
      span : Span
      value_span : Span
      namespace_declaration : Bool
    } derive(Eq, 
    Debug    )

    XmlAttribute::equal

    source

    XmlAttribute::not_equal

    source
    fn XmlAttribute::not_equal(x : XmlAttribute, y : XmlAttribute) -> Bool

    XmlAttribute::to_repr

    source

    XmlContent

    source
    pub(all) enum XmlContent {
      Text(String)
      Element(XmlElement)
      Comment(String)
      ProcessingInstruction(target~ : String, data~ : String)
    } derive(Eq, 
    Debug    )

    Preserved XML content has string-valued attributes and its own namespace scope. A known BPMN name inside this payload remains XML payload data.

    XmlContent::equal

    source
    fn XmlContent::equal(XmlContent, XmlContent) -> Bool

    XmlContent::not_equal

    source
    fn XmlContent::not_equal(x : XmlContent, y : XmlContent) -> Bool

    XmlContent::to_repr

    source

    XmlElement

    source
    pub struct XmlElement {
      element : Element
    } derive(Eq, 
    Debug    )

    XmlElement::attributes

    source
    fn XmlElement::attributes(self : XmlElement) -> ReadOnlyArray[Attribute]

    XmlElement::bindings

    source
    fn XmlElement::bindings(self : XmlElement) -> ReadOnlyArray[(String, String)]

    XmlElement::contents

    source
    fn XmlElement::contents(self : XmlElement) -> ReadOnlyArray[Content]

    XmlElement::equal

    source
    fn XmlElement::equal(XmlElement, XmlElement) -> Bool

    XmlElement::from_element

    source
    fn XmlElement::from_element(element : Element) -> XmlElement?

    XmlElement::name

    source
    fn XmlElement::name(self : XmlElement) -> ExpandedName

    XmlElement::namespace_binding

    source
    fn XmlElement::namespace_binding(self : XmlElement, prefix : String) -> String?

    XmlElement::new

    source
    fn XmlElement::new(name : ExpandedName, attributes? : ArrayView[(ExpandedName, String)], contents? : ArrayView[XmlContent], bindings? : ArrayView[(String, String)]) -> XmlElement

    XmlElement::not_equal

    source
    fn XmlElement::not_equal(x : XmlElement, y : XmlElement) -> Bool

    XmlElement::to_repr

    source

    XmlNode

    source
    pub struct XmlNode {
      kind : XmlNodeKind
      raw_name : String
      name : ExpandedName?
      attributes : ReadOnlyArray[XmlAttribute]
      bindings : ReadOnlyArray[(String, String)]
      children : ReadOnlyArray[Int]
      parent : Int?
      span : Span
      value : String
      complete : Bool
    } derive(Eq, 
    Debug    )

    Nodes use local arena indexes, so deeply nested XML does not require recursive values or recursive CST operations. Bindings are declarations on this node.

    XmlNode::equal

    source
    fn XmlNode::equal(XmlNode, XmlNode) -> Bool

    XmlNode::not_equal

    source
    fn XmlNode::not_equal(x : XmlNode, y : XmlNode) -> Bool

    XmlNode::to_repr

    source

    XmlNodeKind

    source
    pub(all) enum XmlNodeKind {
      Document
      Element
      Text
      Comment
      ProcessingInstruction
      CData
      Declaration
      Error
    } derive(Eq, 
    Debug    )

    XmlNodeKind::equal

    source
    fn XmlNodeKind::equal(XmlNodeKind, XmlNodeKind) -> Bool

    XmlNodeKind::not_equal

    source
    fn XmlNodeKind::not_equal(x : XmlNodeKind, y : XmlNodeKind) -> Bool

    XmlNodeKind::to_repr

    source

    accept

    source
    fn[V : Visitor] accept(root : NodeRef, visitor : V) -> Unit

    fold

    source
    fn[A] fold(root : NodeRef, initial : A, enter : (A, NodeRef) -> (A, Control), leave? : (A, NodeRef) -> A) -> A

    graph_diagnostic_codes

    source
    let graph_diagnostic_codes : ReadOnlyArray[String]

    kind_from_name

    source
    fn kind_from_name(name : ExpandedName) -> Kind?

    push_events

    source
    fn[S : EventSource] push_events(source : S, enter : (NodeRef) -> Control, leave? : (NodeRef) -> Unit) -> Unit

    read

    source
    fn read(source : String, source_id? : String, limits? : Limits) -> ReadResult

    Read decoded XML without resource access. CST reproduction remains available after errors or limit exhaustion; a syntax error prevents typed lowering.

    reduce

    source
    fn[R] reduce(root : NodeRef, combine : (NodeRef, ArrayView[R]) -> R) -> R

    reduce_pruned

    source
    fn[R] reduce_pruned(root : NodeRef, enter : (NodeRef) -> Control, combine : (NodeRef, ArrayView[R]) -> R) -> R?

    reference_rules

    source
    let reference_rules : ReadOnlyArray[ReferenceRule]

    resolve_references

    source
    fn resolve_references(index : DocumentIndex, resources? : ResourceSet, resource_id? : String, limits? : Limits) -> ReferenceResult

    Resolve declared BPMN references over one document and its explicit imports. Missing imports are findings; they do not invalidate unrelated local lookups.

    schema_elements

    source
    let schema_elements : ReadOnlyArray[SchemaElement]

    schema_fields

    source
    let schema_fields : ReadOnlyArray[SchemaField]

    schema_groups

    source
    let schema_groups : ReadOnlyArray[SchemaGroup]

    schema_type

    source
    fn schema_type(name : ExpandedName) -> SchemaType?

    schema_types

    source
    let schema_types : ReadOnlyArray[SchemaType]

    standard_kinds

    source
    let standard_kinds : ReadOnlyArray[Kind]

    traversal_diagnostic_codes

    source
    let traversal_diagnostic_codes : ReadOnlyArray[String]

    try_write

    source
    fn try_write(document : Document, format? : WriteFormat, limits? : Limits) -> WriteResult

    Canonical XML with deterministic namespaces and expanded-name attribute order. A failed result never exposes the partially assembled buffer as output.

    typed_model_fields

    source
    let typed_model_fields : ReadOnlyArray[(TypeId, SchemaFieldKind, ExpandedName)]

    Every generated attribute/child accessor, including inherited fields.

    typed_model_types

    source
    let typed_model_types : ReadOnlyArray[TypeId]

    All complex schema types with immutable typed model APIs.

    validate

    source
    fn validate(document : Document, resources? : ResourceSet, resource_id? : String, limits? : Limits) -> ValidationResult

    Complete means all requested processing finished, not that the model is valid. Error findings and the original immutable document coexist.

    validate_read

    source
    fn validate_read(result : ReadResult, resources? : ResourceSet, resource_id? : String, limits? : Limits) -> ValidationResult

    Retain XML/lowering findings alongside the explicit structural and reference stages. A syntax failure never invents a typed document or a source span.

    validate_structure

    source
    fn validate_structure(document : Document, resource_id? : String, limits? : Limits) -> StructureResult

    Structural validation keeps incomplete documents inspectable. complete describes processing, not whether the document has errors.

    validation_diagnostic_codes

    source
    let validation_diagnostic_codes : ReadOnlyArray[String]

    walk

    source
    fn walk(root : NodeRef, enter : (NodeRef) -> Control, leave? : (NodeRef) -> Unit) -> Unit

    write

    source
    fn write(document : Document, format? : WriteFormat, limits? : Limits) -> String raise WriteError

    Convenience writer. Handle WriteError for invalid constructed values or use try_write when an explicit result is more convenient.

    xml_diagnostic_codes

    source
    let xml_diagnostic_codes : ReadOnlyArray[String]

    Stable XML syntax/namespace/limit diagnostic inventory. BPMN lowering codes are separate; later structural/reference stages do not use this inventory.

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    Ā© 2026 mooncakes.io