eContracts Version 1.0

7.2. Description

This can contain an entire address (see example under party). Or it may contain part of an address, with each part having an appropriate category (see example below).

7.2.1. Attributes

7.2.2. Parents

These elements contain address: text, person-record

7.2.3. Children

The following elements occur inside address:

conditional, em, field, reference, statutory-em, strike, sub, sup

7.2.4. See Also

name, party and person-record

7.2.5. Examples

Example B.1. Several address elements which together define all parts of an address

<?xml version="1.0" encoding="utf-8"?>
<contract xmlns="urn:oasis:names:tc:eContracts:1:0"
          xmlns:dc="http://purl.org/dc/elements/1.1/"
          xmlns:xi="http://www.w3.org/2001/XInclude">

  <title><text>Sample of :
               - contract-front
               - parties
               - party
               - person-record
               - name
               - address
  </text></title>

  <contract-front>

    <parties>
      <party>
        <person-record>
          <name>John Smith</name>
          <address class="street">2-198 Lamoine Avenue</address>
          <address class="city">Macomb</address><address class="state">IL</address>
        </person-record>
      </party>
    </parties>

  </contract-front>

  <body></body>

</contract>

8. attachment

8.1. Synopsis

8.1.1. Content Model

attachment = element attachment {
    metadata?, title?, subtitle*,
    (attachment.doctypes | attachment.structure.model)?,

    attachment.attlist
}

attachment.structure.model = loose.structure.model

attachment.attlist =
    common.attributes,
    common.number.attribute,
    attachment.class.attribute,
    orient.attribute,
    stop-contents.attribute,
    attachment.numbering.attributes,
    attachment.attlist.extensions

attachment.numbering.attributes =   empty
attachment.class.attribute =        standard.class
attachment.attlist.extensions =     empty
attachment.doctypes =               contract

## Tight structure model
tight.structure.model = inclusion*,
                ((block, inclusion*)+ | (item.reuse.model+, inclusion*))?



## Standard structure model
standard.structure.model = inclusion*, (block, inclusion*)*,
                 (item.reuse.model+, inclusion*)


## Loose structure model
loose.structure.model = (block | inclusion | item.reuse.model)*

    item.reuse.model |= xiInclude

attachment ::=

Sequence of
- Zero or one metadata
- Zero or one title
- Zero or more subtitle
- Zero or one of:
  - contract
    If loose model is selected, sequence of:
    Zero or more of:
    block
    inclusion
    item
    xi:include
    
    If standard model is selected, sequence of:
    Zero or more inclusion
    Zero or more sequences of
    One block
    Zero or more inclusion
    
    Sequence of
    One or more choice of
    item
    xi:include
    
    Zero or more inclusion
    
    If tight structure model is selected, sequence of
    Zero or more of inclusion
    Zero or one of:
    One or more Sequences of
    One block
    Zero or more inclusion
    
    Sequence of
    One or more sequences of
    item
    xi:include
    
    Zero or more inclusion

8.1.2. Attributes

Common Attributes, common.number.attribute, Class Attributes, orient.attribute, and Stop-Contents Attribute

8.2. Description

This element is a container for a single attachment such as a schedule, exhibit or appendix to the contract.

A key feature of the attachment is that it can contain a separate eContract as well as the standard narrative structures. This allows a contract to be included as an attachment to another contract.

By default, this element uses the Loose structure model for narrative content. The structure model used for the attachemnt element may be changed to one of the other structure models defined in this file as part of a customization.

8.2.1. Attributes

Common Attributes, common.number.attribute, Class Attributes, orient.attribute, Stop-Contents Attribute, and common.number.attribute

8.2.2. Parents

These elements contain attachment: attachments

8.2.3. Children

The following elements occur inside attachment: block, contract, inclusion, item (outside of a block), metadata, subtitle, title, and xi:include

8.2.4. Examples

Please see attachments

9. attachments

9.1. Synopsis

9.1.1. Content Model


attachments = element attachments {

    attachment+,

    attachments.attlist
}


attachments.attlist =
    common.attributes,
    attachment.numbering.attributes,
    attachments.attlist.extensions

attachments.numbering.attributes =      empty
attachments.attlist.extensions = empty


attachments ::=

One or more attachment

9.1.2. Attributes

9.2. Description

This is the container for one or more attachment elements. This element may be used to separate or group the attached content for automatic number or layout purposes.

9.2.1. Attributes

9.2.2. Parents

These elements contain attachments: contract

9.2.3. Children

The following elements occur inside attachments: attachment

9.2.4. See Also:

object and back

9.2.5. Examples:

Example B.2. An attachments with a single attachment element

<?xml version="1.0" encoding="utf-8"?>
<contract xmlns="urn:oasis:names:tc:eContracts:1:0"
          xmlns:dc="http://purl.org/dc/elements/1.1/"
          xmlns:xi="http://www.w3.org/2001/XInclude">

  <title><text>Sample of
               - attachments
               - attachment
               - title
               - block
               - text
  </text></title>

  <body></body>

  <attachments>
    <attachment class="appendix" id="a1" number="15">
      <title><text>Form of notice in Schema files</text></title>
      <block><text>They must be sent regular mail.</text></block>
      <block><text>Standard Schema
          <reference href="http://www.elkera.com" print-url="true">
can be read on the web easily!</reference>.</text></block>
    </attachment>
 </attachments>

</contract>

10. back

10.1. Synopsis

back -- contains elements that follows the body of the contract including signatures.

10.1.1. Content model

back = element back {
    title?, ((back.structure.model | party-signature)* & date-block?),

    back.attlist
}

back.structure.model = loose.structure.model


back.attlist =
    common.attributes,
    back.numbering.attributes,
    back.attlist.extensions


back.numbering.attributes =     empty
back.attlist.extensions =       empty

back ::=

Sequence of
- One or more of title
- Interleave of
  - Zero or more of
    
    If loose model is selected, sequence of:
    Zero or more of:
    block
    inclusion
    item
    xi:include
    
    If standard model is selected, sequence of:
    Zero or more inclusion
    Zero or more sequences of
    One block
    Zero or more inclusion
    
    Sequence of
    One or more choice of
    item
    xi:include
    
    Zero or more inclusion
    
    If tight structure model is selected, sequence of
    Zero or more of inclusion
    Zero or one of:
    One or more Sequences of
    One block
    Zero or more inclusion
    
    Sequence of
    One or more sequences of
    item
    xi:include
    
    Zero or more inclusion
    
    party-signature
  - Zero or one date-block

10.1.2. Attributes

10.2. Description

The back element contains content that follows the main provisions of the contract, such as signatures and other material. Material found in the back is not hierarchically part of the body.

By default, this element uses the loose structure model for narrative content. The structure model used for the back element may be chagned to one of the other structure modes defined in this file as part of a customization.

10.2.1. Attributes

10.2.2. Parents

These elements contains back: contract

10.2.3. Children

The following elements occur inside back: block, inclusion, item (outside of a block) xi:include, and title

10.2.4. Examples

The following shows the back within a contract including one possible way that signature material could appear.

Example B.3. Back Tag with one signatory and their witness

<?xml version="1.0" encoding="utf-8"?>
<contract xmlns="urn:oasis:names:tc:eContracts:1:0"
          xmlns:dc="http://purl.org/dc/elements/1.1/"
          xmlns:xi="http://www.w3.org/2001/XInclude">

  <title><text>Sample of :
               - back
               - party-signature
               - signatory-group
               - signatory-record
               - signatory
               - signatory-line
  </text></title>

  <body></body>

  <back>

    <party-signature>

      <signatory-group>

        <block> </block>

        <signatory-record>

          <signatory id="T0001" xml:lang="ja">
            <signature-line id="I0001" xml:lang="en_US">
              <text>Mr. Signatory Jr.</text>
              <field>Field for a text.</field>
            </signature-line>
          </signatory>

          <witness>
            <signature-line id="I0002" xml:lang="fr">
              <text>Ms. Witness Arcole</text>
              <field>Field for a text.</field>
            </signature-line>
          </witness>

        </signatory-record>

      </signatory-group>

    </party-signature>

  </back>

</contract>

11. background

11.1. Synopsis

11.1.1. Content Model

background = element background {

    title?, item.reuse.model*,

    background.attlist
}

item.reuse.model = (item)
    item.reuse.model |= xiInclude


background.attlist =
    common.attributes,
    backgound.numbering.attributes,
    background.attlist.extensions


backgound.numbering.attributes =    empty
background.attlist.extensions =     empty

background ::=

Sequence of
- Zero or one title
- Zero or more occurences of choice of:
  - item
  - xi:include

11.1.2. Attributes

11.2. Description

This contains recitals and other "background" information.

11.2.1. Attributes

Common Attributes common.number.attribute

11.2.2. Parents

background appears inside: contract-front

11.2.3. Children

The following elements occur inside background: item title xi:include

11.2.4. Examples

Please see parties.

12. block

block -- The container for a structural or grammatical paragraph.

12.1. Synopsis

12.1.1. Content model

block = element block {
            (block.level.elements |
                    element item {
                        metadata?, title?, (block | inclusion)*,
                        block.item.attlist
                    }
              )*,

    block.attlist
}


block.level.elements = text.container.element | definition | table | inclusion
text.container.element = \text


block.attlist =
    common.attributes,
    block.class.attribute,
    conditional.attributes,
    block.numbering.attributes,
    block.attlist.extensions


    conditional.attributes &= condition.attribute

block.numbering.attributes =
    block.number.type


block.class.attribute = standard.class
block.number.type =     attribute number-type { ListItemNumberTypes }?

ListItemNumberTypes =   "manual"
                      | "none"
                      | "disc"
                      | "line"
                      | "number"
                      | "loweralpha"
                      | "upperalpha"
                      | "lowerroman"
                      | "upperroman"

block.attlist.extensions = empty

block ::=

Zero or more of:

12.1.2. Attributes

Additional attributes:

number-type(enumeration)
- "manual"
- "none"
- "disc"
- "line"
- "number"
- "loweralpha"
- "upperalpha"
- "lowerroman"
- "upperroman"

12.1.3. Additional Constraints

If this block contains a number-type = manual, then the contract writer SHOULD manually nubmer each list item by putting a number attribute on each of the item elements directly within this block.

12.2. Description

The block is the container element for a structural or grammatical paragraph. The actual text data of the paragraph is put in the text element.

Within a block, an item will be considered an element of a list. A block MAY contain the text element directly, an item, as well as definition, table, inclusion, party or person-record.

12.2.1. Attributes

Additional attributes:

number-type number-type indicates the type of numbering or markers to be used on contained list items.

Table B.1. (enumeration)

"manual"	The contract writer SHOULD indicate list items by putting a `number` attribute on each of the `item` tags directly enclosed within this `block`
"none"	The application programmer SHOULD render list items without any marker or number.
"disc"	The application programmmer SHOULD render list items by a disc or bullet.
"line"	The application programmer SHOULD render listitems items marked by a line or dash.
"number"	The application programmer SHOULD render list items proceeded by numerals ('1', '2', '3', ...).
"loweralpha"	The application programmer should render list items proceeded by 'a', 'b', 'c', .... 'z', 'aa', 'ab', 'ac', 'ad' ... 'za', 'zb', 'zc'...'zz'
"upperalpha"	The application programmer should render list items proceeded by 'A', 'B', 'C', ... 'Z', 'AA', 'AB', 'AC', 'AD'... 'ZA', 'ZB', ...'ZZZ'
"lowerroman"	The application programmer should render list items as 'i', 'ii', 'iii', 'iv', ...
"upperroman"	The application programmmer should render list items proceeded by upper case Roman numerals ('I', 'II', 'III', 'IV', ...)

12.2.2. Parents

These elements contain block: attachment definition inclusion item item (inside a block), note party-signature signatory signatory-group signatory-record witness

12.2.3. Children

The following elements in occur in block: item (inside a block), definition inclusion block.item table text

12.2.4. Examples

See body.

13. body

13.1. Synopsis

body - The body of the contract

13.1.1. Content model

body = element body {

    title?, body.structure.model,

    body.attlist
}


body.structure.model = loose.structure.model

body.attlist =
    common.attributes,
    body.attlist.extensions

body.attlist.extensions = empty



## Tight structure model
tight.structure.model = inclusion*,
                ((block, inclusion*)+ | (item.reuse.model+, inclusion*))?



## Standard structure model
standard.structure.model = inclusion*, (block, inclusion*)*,
                 (item.reuse.model+, inclusion*)


## Loose structure model
loose.structure.model = (block | inclusion | item.reuse.model)*

item.reuse.model = (item)
    item.reuse.model |= xiInclude

body ::=

Zero or one of
- title
  - If loose model is selected, sequence of:
    Zero or more of:
    block
    inclusion
    item
    xi:include
  - If standard model is selected, sequence of:
    Zero or more inclusion
    Zero or more sequences of
    One block
    Zero or more inclusion
    
    Sequence of
    One or more choice of
    item
    xi:include
    
    Zero or more inclusion
  - If tight structure model is selected, sequence of
    Zero or more of inclusion
    Zero or one of:
    One or more Sequences of
    One block
    Zero or more inclusion
    
    Sequence of
    One or more sequences of
    item
    xi:include
    
    Zero or more inclusion

13.1.2. Attributes

13.2. Description

A body must appear in the XML for a contract document.

The body is a container to shield the main part of the contract so items within it can be automatically numbered and rendered independently of the other parts of the contract.

By default, this element uses the loose structure model for narrative content. The structure model used for the body may be changed to one of the other structure models defined in this file as part of a customization.

13.2.1. Parents

These elements contain body: contract

13.2.2. Children

The following elements occur in body: block, inclusion, item (outside of a block), title. xi:include

13.2.3. Examples

Example B.4. A valid body under the loose model

<?xml version="1.0" encoding="utf-8"?>
<contract xmlns="urn:oasis:names:tc:eContracts:1:0"
          xmlns:dc="http://purl.org/dc/elements/1.1/"
          xmlns:xi="http://www.w3.org/2001/XInclude">

 <title><text>Sample Loose model data</text></title>

 <body>
   <block> </block>
   <block> </block>
   <item>  </item>
   <item>
     <block></block>
     <item> </item>
     <block></block>
     <item> </item>
   </item>
   <block> </block>
   <item>  </item>
 </body>

</contract>

Example B.5. A valid body under the standard model

<?xml version="1.0" encoding="utf-8"?>
<contract xmlns="urn:oasis:names:tc:eContracts:1:0"
          xmlns:dc="http://purl.org/dc/elements/1.1/"
          xmlns:xi="http://www.w3.org/2001/XInclude">

 <title><text>Sample Standard model data</text></title>
 <subtitle>body is valid as standard model. back is not.</subtitle>

 <body>
   <block> </block>
   <block> </block>
   <item>  </item>
   <item>  </item>
 </body>

 <back>
   <item>  </item>
   <item>  </item>
   <block> </block>
   <block> </block>
 </back>

</contract>

Example B.6. A valid body under the tight model.

<?xml version="1.0" encoding="utf-8"?>
<contract xmlns="urn:oasis:names:tc:eContracts:1:0"
          xmlns:dc="http://purl.org/dc/elements/1.1/"
          xmlns:xi="http://www.w3.org/2001/XInclude">

 <title><text>Sample Tight model data</text></title>

 <body>
   <item>
     <block></block>
     <block></block>
   </item>
   <item>
     <item> </item>
     <item> </item>
   </item>
 </body>

</contract>

14. citation

14.1. Synopsis

14.1.1. Content Model

citation = element citation {
    inline.content,

    citation.attlist
}



inline.content = (inline.content.inner)*
inline.content.inner = text | reference | em | statutory-em | strike | sub | sup | field
    inline.content.inner |= conditional

citation.attlist =
    common.attributes,
    citation.attlist.extensions


citation.attlist.extensions = empty

citation ::=

Zero or more of

14.1.2. Attributes

14.2. Description

The citation is the name by which a referenced work is cited.

14.2.1. Processing Expectations

It is expected that this text SHOULD be rendered in-line.

14.2.2. Attributes

14.2.3. Parents

These elements contain citation: reference

14.2.4. Children

The following elements occur inside citation:

conditional, em, field, reference, statutory-em, strike, sub, sup

14.2.5. Examples

See reference

15. colspec

15.1. Synopsis

This is used to provide formatting information and designators for columns within a tgroup of a table.

15.1.1. Content Model

colspec = element colspec {
    empty,

    colspec.attlist
}

colspec.attlist =
    common.attributes,
    attribute colnum      { xsd:NMTOKEN }?,
    attribute colname     { xsd:NMTOKEN }?,
    attribute colwidth    { xsd:string }?,
    attribute colsep      { xsd:boolean }?,
    attribute rowsep      { xsd:boolean }?,
    attribute align       { TableAlign }?,
    colspec.attlist.extensions

colspec.attlist.extensions = empty

TableAlign = "left" | "right" | "center" | "justify"

colspec is empty.

15.1.2. Attributes

Additional Attributes:

align
colname
colnum
colsep
colwidth
rowsep

15.2. Description

This is a column specification in a table. This element and all other elements contained by table are taken from OASIS Exchange Table Model. Please refer to that specification for full details of this element: [table1], [table2].

The contract writer SHOULD provide one colspec for each column of their table. The contract writer MAY provide a name (colname), a number (colnum) to designate their column as well as formatting information with its remaining attributes.

15.2.1. Attributes

Additional Attributes:

This section only provides a brief description of each attribute's purpose. Please refer to the OASIS Exchange Model for details and processing semantics for these attributes.

align

This is the default alignment for table cells within the column defined by the colspec:

Table B.2. (enumeration)

`left`	align to the left (default)
`right`	align to the right
`center`	center the text
`justify`	justify the text

colname

The name of the column

colnum

The number of the column

colsep

This controls the display of the column separator to the right of this cell in the table.

colwidth

The width of the column

rowsep

This controls the display of the row separator underneath this cell in the table.

15.2.2. Parents

These elements contain colspec: tgroup

15.2.3. Children

No elements occur inside colspec.

15.2.4. See Also

Some of this information may be overriden in row and entry elements.

15.2.5. Example

Please see table

16. conditional

16.1. Synopsis

16.1.1. Content Model

Conditional has a mixed content model

conditional = element conditional {
    inline.content,

    conditional.attlist
}


conditional.attlist =
        common.attributes,
        conditional.attributes,
        conditional.attlist.extensions


    conditional.attributes = empty
    conditional.attributes &= condition.attribute

conditional.attlist.extensions = empty



inline.content = (inline.content.inner)*
inline.content.inner = text | reference | em | statutory-em | strike | sub | sup | field

    inline.content.inner |= conditional

conditional ::=

Zero or More of

16.1.2. Attributes

16.2. Description

This is for text that will only be included in some versions of the document. See condition.meta and conditions.

16.2.1. Attributes

See Conditional text processing in Contract Document Structure in the eContracts Schema

16.2.2. Parents

These elements contain conditional: text address, citation, conditional, date, date-block, em, fallback, name, note-in-line, phrase, reference, statutory-em, strike, sub, subtitle, sup, term, terms, text and xi:fallback

16.2.3. Children

The following elements occur inside: conditional

conditional, em, field, reference, statutory-em, strike, sub, sup

16.2.4. Examples

See conditions.

17. condition

17.1. Synopsis

This defines one of the required strings that must match a condition attribute in a block or similar element in order for that content to be included in a particular instance of a contract.

17.1.1. Content Model

condition has a mixed content model.

div {

    # add the conditions structure to the metadata element
    metadata.content &=

        # define the conditions element and its children
        element conditions {

            element condition {
                text,

                attribute name { xsd:string },
                attribute default { xsd:boolean }?
            }+
        }?

}

condition is empty

17.1.2. Attributes

"name"
"default"

17.2. Description

The condition element is used to specify active conditions when rendering conditional text. The active condition is specified using the name attribute of the condition element. See the conditions element for a full description of this element.

17.2.1. Attributes

name: The value of this is matched against the list of strings in a conditional, which is within the regular text or a condition attribute on an element in the regular contract text.
default: This is a boolean true or false.

17.2.2. Parents

These elements contain: condition: conditions

17.2.3. Children

No elements occur inside condition.

17.2.4. See Also:

conditional.

17.2.5. Examples

See the two examples under conditions

18. conditions

18.1. Synopsis

18.1.1. Content Model

    metadata.content &=

        # define the conditions element and its children
        element conditions {

            element condition {
                text,

                attribute name { xsd:string },
                attribute default { xsd:boolean }?
            }+
        }?

conditions ::=

Zero or more
- group

18.1.2. Attributes

none

18.2. Description

The conditions element may be used in the metadata to set the values for active conditions on conditional text in the contract.

When the conditional text functionality is activated in the eContracts schema, all eContracts elements are given a condition attribute. The condition attribute is used to specify a name for the condition or conditions that must be active before the processing application will output the element in a rendered contract.

User applications may implement control of conditional text differently, possibly by storing the active conditions elment in a separate file, or by giving control to another application, such as the rendering application. This is left to the application programmer.

The conditions is provided as a simple mechanism for controlling condtional text within a single contract. Some applications may prefer to implement control of conditional text differently, possibly by storing the active conditions element in a separate file, or by giving control to another application, such as the rendering application. This is left to the application developer.

The condition element is used to specify active condtions when rendering conditional text. The active condition is specified using the name attribute of the condition element. For example,


<contract>
<conditions><condition name="US">United States</condition></conditions>
...
<block condition="US"><text>A jurisdiction-specific statement in the
contract.</text></block>
<block condition="AU"><text>A jurisdiction-specific statement in the contract.</text></block>
</contract>

In this example, the statement for the US jurisdiction would be rendered by the processing application. The statement for the AU jurisidiction would not. If the condition element's name attribute was changed so that <condition name="AU"> .. </condition>, only the statement for the AU jurisdiction would be rendered. If the condition element was removed, neither of the phrases would be rendered by the processing application.

An element can have multiple conditions set:

<block condition="US AU">
   <text>A statement specific to both US and AU jurisdictions</text>
</block>

In this example, the statement would be rendered when a condition element existed for either jurisdictions, i.e.,

18.2.1. Attributes

none

18.2.2. Parents

These elements contain conditions: metadata

18.2.3. Children

The following elements occur inside conditions: condition

18.2.4. See Also

conditional inside a regular inline element.

18.2.5. Examples

19. contract

19.1. Synopsis

This is the root element of the eContracts schema.

19.1.1. Content Model

contract = element contract {
    metadata?, title, subtitle*,
    contract-front?,
    body,
    back?,
    attachments*,

    contract.attlist
}


contract.attlist =
    common.attributes,
    contract.class.attribute,
    orient.attribute,
    contract.numbering.attributes,
    contract.attlist.extensions


contract.numbering.attributes = empty
contract.class.attribute =      standard.class
contract.attlist.extensions =   empty

contract ::=

Sequence of
- Zero or one metadata
- one title
- Zero or more subtitle
- Zero or one contract-front
- One body
- Zero or one back
- Zero or more attachments

19.1.2. Attributes

Common Attributes Class Attributes orient.attribute

19.2. Description

This is the root element for any contract created using the eContracts schema. This element can also appear inside an attachment element to allow a contract to be added as an attachment to the contract.

19.2.1. Parents

These elements may also contain contract: attachment

19.2.2. Children

The following elements occur inside contract: attachments back body metadata subtitle title

19.2.3. Examples

This illustrates the basic structure of a contract:

Example B.7. Basic Structure of a Contract

<?xml version="1.0" encoding="utf-8"?>
<contract xmlns="urn:oasis:names:tc:eContracts:1:0">

  <title><text>Sample of the five elements at level 1 </text></title>

  <subtitle>This file is to test : - title - sub-title - contract-front -
       date-block - parties - party - body - back -
              attachments - attachment
            </subtitle>

  <contract-front>
     <date-block>
       <date><em>Long time ago</em></date>
     </date-block>
     <parties>
       <party></party>
     </parties>
  </contract-front>

  <body></body>

  <back></back>

  <attachments>
    <attachment> </attachment>
  </attachments>

</contract>

Here is an example showing a minimal contract which would consist have only a title and a body:

Example B.8. A Minimal Contract

<?xml version="1.0" encoding="utf-8"?>
<contract xmlns="urn:oasis:names:tc:eContracts:1:0"
          xmlns:dc="http://purl.org/dc/elements/1.1/"
          xmlns:xi="http://www.w3.org/2001/XInclude">
 <title><text>Minimum XML sample</text></title>
 <body>
 </body>
</contract>

20. contract-front

20.1. Synopsis

20.1.1. Content Model


contract-front = element contract-front {

    (((date-block?, parties) | block+), background?),

    contract-front.attlist
}


contract-front.attlist =
    common.attributes,
    contract-front.class.attribute,
    contract-front.attlist.extensions


contract-front.class.attribute =    standard.class
contract-front.attlist.extensions = empty

contract-front::=

Sequence of
- Choice of
  - Sequence of
    Zero or more date-block
    One parties
  - One or more block
- Zero or one background

20.1.2. Attributes

20.2. Description

This contains the information that is traditionally found at the beginning of a contract that includes date-block, parties and background.

20.2.1. Attributes

20.2.2. Parents

These elements contain contract-front: contract

20.2.3. Children

The following elements occur inside contract-front: background block date-block parties

20.2.4. Examples

Example B.9. A contract-front with a date-block and parties.

<?xml version="1.0" encoding="utf-8"?>
<contract xmlns="urn:oasis:names:tc:eContracts:1:0">

  <title><text>Sample of the five elements at level 1 </text></title>

  <subtitle>This file is to test : - title - sub-title - contract-front -
       date-block - parties - party - body - back -
              attachments - attachment
            </subtitle>

  <contract-front>
     <date-block>
       <date><em>Long time ago</em></date>
     </date-block>
     <parties>
       <party></party>
     </parties>
  </contract-front>

  <body></body>

  <back></back>

  <attachments>
    <attachment> </attachment>
  </attachments>

</contract>

Example B.10. A contract front with a block of text

<?xml version="1.0" encoding="utf-8"?>
<contract xmlns="urn:oasis:names:tc:eContracts:1:0"
          xmlns:dc="http://purl.org/dc/elements/1.1/"
          xmlns:xi="http://www.w3.org/2001/XInclude">

  <title> <text>Sample of :
           - contract-front
           - block
           - text
           - citation
           - background
          </text>
  </title>

  <contract-front>
    <block>
      <text>Elkera Pty Limited is the original developer of the XML schema and
              accompanying documents
            described as the <reference><citation>BNML Schema</citation>
             </reference>. The BNML Schema
            is designed to be adapted and extended for use in a wide variety
              of applications.
      </text>
    </block>
    <background> </background>
  </contract-front>

 <body> </body>

</contract>

21. data

21.1. Synopsis

21.1.1. Content Model

data = element data {
        data.content,

        data.attlist
}

data.content = empty

data.attlist =
        common.attributes,
        data.src.attribute,
        data.height.attribute,
        data.width.attribute,
        data.attlist.extensions


data.src.attribute =    attribute src { xsd:string }?
data.height.attribute = attribute height   { xsd:integer }?
data.width.attribute =  attribute width   { xsd:integer }?

data.attlist.extensions = empty

21.1.2. Attributes

height
src
width

21.2. Description

This is used to reference the source file and specify dimensions for a multimedia object, particularly images.

21.2.1. Attributes

height: This integer gives the height of the picture. (Units are not defined by this specification.)
src: This gives the file path or URI for the multimedia information.
width: This integer gives the width of the picture. (Units are not defined by this specification.)

21.2.2. Parents

data appears inside: object

21.2.3. Children

No elements occur inside data.

21.2.4. See Also

fallback

21.2.5. Examples

Please see fallback.XML under fallback

22. date

22.1. Synopsis

22.1.1. Content Model

date has a mixed content model.

date = element date {
    (inline.content )*,

    date.attlist
}

date.attlist =
        common.attributes,
        date.class.attribute,
        date.name.attribute,
        date.attlist.extensions

date.class.attribute =      standard.class
date.name.attribute =       attribute name { xsd:string }?
date.attlist.extensions =   empty


inline.content = (inline.content.inner)*
inline.content.inner = text | reference | em | statutory-em | strike | sub | sup | field

    inline.content.inner |= conditional

date ::=

Zero or More of

22.1.2. Attributes

22.2. Description

This is used to indicate a date. This schema does not specify the date format. The application programmer or contract writer may use a format that is appropriate to the contract.

22.2.1. Attributes

date-block name field party person-record

22.2.2. Parents

These elements contain date: date-block and text

22.2.3. Children

The following elements occur inside date:

conditional, em, field, reference, statutory-em, strike, sub, sup

22.2.4. See Also

22.2.5. Examples

See the first example inside contract.

23. date-block

23.1. Synopsis

23.1.1. Content Model

date-block has a mixed content model.

date-block = element date-block {
    (text.content.inner)*,

    date-block.attlist
}


inline.content = (inline.content.inner)*
inline.content.inner = text | reference | em | statutory-em | strike | sub | sup | field

    inline.content.inner |= conditional

text.content = (text.content.inner)*
text.content.inner = inline.content.inner | object | term | phrase | field
                     | note | note-in-line | name | address | date | party | person-record


date-block.attlist =
    common.attributes,
    date-block.attlist.extensions

date-block.attlist.extensions = empty

date-block ::=

Zero or More of

23.1.2. Attributes

23.2. Description

This is used to format a date on a separate line.

23.2.1. Attributes

dc:creator dc:publisher

23.2.2. Parents

These elements contain date-block: contract-front and back

23.2.3. Children

The following elements occur inside date-block: address, em, date, field, name, note, note-in-line, object, party, person-record, phrase reference, statutory-em, strike, sub, sup, term

23.2.4. See Also

parties

23.2.5. Example:

Please see the first example in contract.

24. dc:contributor

24.1. Synopsis

A person, organization, service or other entity which made a contribution to the content.

24.1.1. Content Model

            element dc:contributor { xsd:string }* &

dc:contributor ::= string

24.1.2. Attributes

This element has no attributes.

24.2. Description

A person, organization, service or other entity which made a contribution to the content. This element is taken from the Dublin Core Metadata Elemetn Set dc. Please refer to that specification for a description of the semantics of this element.

24.2.1. Attributes

This element has no attributes.

24.2.2. Parents

These elements contain dc:contributor: metadata

24.2.3. Children

No elements occur inside dc:contributor.

24.2.4. See Also

24.2.5. Examples

Please see metadata

25. dc:creator

25.1. Synopsis

This is the name of the "entity primarily responsible for making the content" of this contract.

25.1.1. Content Model

            element dc:creator { xsd:string }* &

dc:creator := string

25.1.2. Attributes

This element has no attributes.

25.2. Description

This is the name of the "entity primarily responsible for making the content" of this contract. It may be a person, organization or service. This element is taken from the Dublin Core Metadata Element set dc. Please refer to that specification for a description of the semantics of this element.

25.2.1. Attributes

This element has no attributes.

25.2.2. Parents

dc:creator appears inside metadata

25.2.3. Children

No elements occur inside dc:creator.

25.2.4. Examples

Please see metadata

26. dc:date

26.1. Synopsis

A date associated with the "lifecycle" of the resource.

26.1.1. Content Model

            element dc:date { xsd:date
                { pattern = "[0-9]{4}-[0-9]{2}-[0-9]{2}" }
            }? &

26.1.2. Attributes

This element has no attributes.

26.2. Description

This is formally described to be any date associated with the "lifecycle" of the resource but typically it will be the date of creation or availability. Its format will consist of a four-digit year, a dash, a two-digit month, and a two-digit day of the month. This element is taken from the Dublin Core Metadata Element set dc. Please refer to that specification for a description of the semantics of this element.

26.2.1. Attributes

This element has no attributes.

26.2.2. Parents

These elements contain dc:date: metadata

26.2.3. Children

No elements occur inside dc:date.

26.2.4. Examples

Please see metadata

27. dc:description

27.1. Synopsis

A description of the contract.

27.1.1. Content Model

            element dc:description { xsd:string } ? &

dc:description ::= string

27.1.2. Attributes

This element has no attributes.

27.2. Description

This is a description of the contract.

This element appears within the metadata. This element is taken from the Dublin Core Metadata Element set dc. Please refer to that specification for a description of the semantics of this element.

27.2.1. Attributes

This element has no attributes.

27.2.2. Parents

These elements contain dc:description: metadata

27.2.3. Children

No elements occur inside dc:description.

27.2.4. See Also

dc:subject

27.2.5. Examples

Please see metadata

28. dc:publisher

28.1. Synopsis

The "entity responsible for making the resource available."

28.1.1. Content Model

            element dc:publisher { xsd:string }? &

dc:publisher ::= string

28.1.2. Attributes

This element has no attributes.

28.2. Description

This element appears within the metadata. This is the entity responsible for making the resource available. This element is taken from the Dublin Core Metadata Element set dc. Please refer to that specification for a description of the semantics of this element.

28.2.1. Attributes

This element has no attributes.

28.2.2. Parents

These elements contain dc:publisher: metadata

28.2.3. Children

No elements occur inside dc:publisher.

28.2.4. See Also

dc:creator

28.2.5. Examples

Please see metadata

29. dc:rights

29.1. Synopsis

Intellectual Property rights, including copyright, for the text of this contract.

29.1.1. Content Model

            element dc:rights { xsd:string }?

dc:rights ::= string

29.1.2. Attributes

This element has no attributes.

29.2. Description

Intellectual Property rights, including copyright, for the text of this contract. This element is taken from the Dublin Core Metadata Element set dc. Please refer to that specification for a description of the semantics of this element.

29.2.1. Attributes

This element has no attributes.

29.2.2. Parents

dc:rights appears inside metadata

29.2.3. Children

No elements occur inside dc:rights.

29.2.4. Examples

Please see metadata

30. dc:subject

30.1. Synopsis

The subject matter of the contract.

30.1.1. Content Model

            element dc:subject { xsd:string }? &

30.1.2. Attributes

This element has no attributes.

30.2. Description

This is a description of the subject of the contract. It may often be a list of key words or selected from a "controlled vocabulary." This element is taken from the Dublin Core Metadata Element set dc. Please refer to that specification for a description of the semantics of this element.

30.2.1. Attributes

This element has no attributes.

30.2.2. Parents

The elements contain dc:subject: metadata

30.2.3. Children

No elements occur inside dc:subject.

30.2.4. See Also

dc:description

30.2.5. Examples

Please see metadata

31. dc:title

31.1. Synopsis

The title or name of the contract.

31.1.1. Content Model

            element dc:title { xsd:string }? &

dc:title := string

31.1.2. Attributes

This element has no attributes.

31.2. Description

The name given to the contract and will be the name by which it will be formally known. This element is taken from the Dublin Core Metadata Element set dc. Please do not confuse this with the title element that is used throughout the rest of the contract.

31.2.1. Attributes

This element has no attributes.

31.2.2. Parents

These elements contain dc:title: metadata

31.2.3. Children

No elements occur inside dc:title.

31.2.4. Examples

Please see metadata

32. definition

32.1. Synopsis

32.1.1. Content Model

definition = element definition {
    (term | terms), block+,

    definition.attlist
}

definition.attlist =
        common.attributes,
        definition.class.attribute,
        definition.attlist.extensions

definition.class.attribute =    standard.class
definition.attlist.extensions = empty

definition ::=

Sequence of
- Choice of
  - term
  - terms
- One or more block

32.1.2. Attributes

32.2. Description

This is for a formal definition structure containing terms and the text which defines their meaning. One uses the terms when there are multiple terms associated with one meaning.

32.2.1. Processing Expectations

Each definition SHOULD appear on a separate line and MAY appear with a hanging indentation.

32.2.2. Attributes

32.2.3. Parents

These elements contain definition: block.

32.2.4. Children

The following elements occur inside definition: block, term and terms

32.2.5. Examples

See field and term.

33. em

33.1. Synopsis

33.1.1. Content Model

em has a mixed content model.

em = element em {
    inline.content,

    em.attlist
}


inline.content = (inline.content.inner)*
inline.content.inner = text | reference | em | statutory-em | strike | sub | sup | field

    inline.content.inner |= conditional
em.attlist =
        common.attributes,
        em.class.attribute,
        em.attlist.extensions

em.class.attribute =    standard.class
em.attlist.extensions = empty

em ::=

Zero or More of

33.1.2. Attributes

33.2. Description

The content is emphasized in some way. This specification does not specify how. Typically, the class attribute would be redefined in a specific application to provide enumerated emphasis types.

33.2.1. Attributes

33.2.2. Parents

These elements contain em: text

33.2.3. Children

The following elements occur inside em:

conditional, em, field, reference, statutory-em, strike, sub, sup

33.2.4. See Also

statutory-em strike

33.2.5. Examples

Example B.11. Example of some in-line elements including em

<contract xmlns="urn:oasis:names:tc:eContracts:1:0"
          xmlns:dc="http://purl.org/dc/elements/1.1/"
          xmlns:xi="http://www.w3.org/2001/XInclude">

  <title><text>Sample of inline elements</text></title>

  <body>
    <block>
      <text>The location to deliver <em>the item</em>
    <strike>has to be one of <statutory-em>designated
    terminals.</statutory-em></strike> will be any places.</text>
    </block>
  </body>

</contract>

34. entry

34.1. Synopsis

This is a table cell.

34.1.1. Content Model

entry = element entry {
    entry.model,

    entry.attlist
}

entry.elements = block | item.reuse.model | inclusion | signature-line
entry.model = (entry.elements)*

item.reuse.model = (item)
    item.reuse.model |= xiInclude

entry.attlist =
    common.attributes,
    attribute colname    { xsd:NMTOKEN }?,
    attribute namest     { xsd:NMTOKEN }?,
    attribute nameend    { xsd:NMTOKEN }?,
    [a:defaultValue = "0"]
    attribute morerows   { xsd:NMTOKEN }?,
    attribute colsep     { xsd:boolean }?,
    attribute rowsep     { xsd:boolean }?,
    attribute align      { TableAlign }?,
    attribute valign     { TableValign }?,
    entry.numbering.attributes,
    entry.attlist.extensions


TableValign = "top" | "middle" | "bottom"

TableAlign = "left" | "right" | "center" | "justify"

entry.numbering.attributes =    empty
entry.attlist.extensions =      empty
    entry.attlist &= attribute is-row-header {xsd:boolean}?
    entry.attlist &= attribute abbreviation { xsd:string }?

entry ::=

Zero or more of

34.1.2. Attributes

Additional Attributes

align
colname
colsep
morerows
nameend
namest
rowsep
valign

34.2. Description

A cell in a table. This element and all other elements contained by table are taken from the OASIS Exchange Table Model. Please refer to that specification for full details of this element. [table1],[table2]

34.2.1. Attributes

This section only provides a brief description of each attribute's purpose. Please refer to the OASIS Exchagne Table Model for details and processing semantics of these attributes.

Additional Attributes:

abbreviation

This attribute is provided to expand an abbreviation found in the entry. This attribute is provided to support the WAI Web Content Accessibility Guidelines.

align

The horizontal alignment for content contained in the cell.

Table B.3. (enumeration)

`left`	align to the left (default)
`right`	align to the right
`center`	center the text
`justify`	justify the text

colname

The column name of the entry.

colsep

This controls the display of the column separator to the right of this cell in the table.

namest

The name of the first column in a column span.

nameend

The name of the last column in a column span.

is-row-header

This attribute indicates the entry is a header for the row. This attribute is provided to support the WAI Web Content Accessibility Guidelines.

morerows

The number of rows in a row span.

rowsep

This controls the display of the row separator underneath this cell in the table.

valign

The vertical alignment of the table cell.

Table B.4. (enumeration)

`top`	Align content at the top of the cell
`middle`	Center content within the cell
`bottom`	Align content at the bottom of the cell.

34.2.2. Parents

These elemetns contain entry: row

34.2.3. Children

The following elements occur inside entry: block, item (outside of a block), xi:include, inclusion, and signature-line

35. fallback

35.1. Synopsis

35.1.1. Content Model

fallback has a mixed content model.

fallback = element fallback {
        (inline.content.inner | object)*,

        fallback.attlist
}



inline.content = (inline.content.inner)*
inline.content.inner = text | reference | em | statutory-em | strike | sub | sup | field

    inline.content.inner |= conditional
fallback.attlist =
        common.attributes,
        fallback.attlist.extensions

fallback.attlist.extensions = empty

fallback::=

Zero or More of

35.1.2. Attributes

35.2. Description

This contains the fallback content for an object. The fallback element is used as the fallback position if an object cannot be rendered by a particular application. If the application cannot retrieve, find or render that object, it would go to the fallback element.

The fallback element can contain text data as well as other objects. This provides for nested object elements allowing for a series of fallback positions. The intention is that the rendering application will fallback until it finds an object it can render. To this end, the innermost fallback should always be only text data.

35.2.1. Attributes

35.2.2. Parents

These elements contain fallback: object.

35.2.3. Children

The following elements occur inside fallback:

conditional, em, field, reference, statutory-em, strike, sub, sup

35.2.4. See Also

data

35.2.5. Examples

Example B.12. an object with several recursive fallback elements

<?xml version="1.0" encoding="utf-8"?>
<contract xmlns="urn:oasis:names:tc:eContracts:1:0"
          xmlns:dc="http://purl.org/dc/elements/1.1/"
          xmlns:xi="http://www.w3.org/2001/XInclude">

  <title><text>Sample of :
               - object
               - fallback
               - data
  </text></title>

  <body>
    <block>

      <text>

        <object type="video/mpeg">
          <data src="mympeg.mpeg" />
          <fallback>
            <object type="image/png">
              <data src="myimage.png" />
              <fallback>The alternate text that should be displayed if both
                        the video and image cannot be displayed.
              </fallback>
            </object>
          </fallback>
        </object>

      </text>

    </block>
  </body>
</contract>

36. field

36.1. Synopsis

36.1.1. Content Model

field = element field {
    text,

    field.attlist
}

field.attlist =
    common.attributes,
    field.class.attribute,
    field.label.attribute,
    field.name.attribute,
    field.type.attribute,
    field.source.attribute,
    field.action.attribute,
    field.length.attribute,
    field.attlist.extensions


field.class.attribute =     standard.class
field.label.attribute =     attribute label { xsd:string }?
field.name.attribute =      attribute name { xsd:string }?
field.type.attribute =      attribute type { xsd:string }?
field.source.attribute =    attribute source { xsd:string }?
field.action.attribute =    attribute action { xsd:string }?
field.length.attribute =    attribute length  { xsd:string }?

field.attlist.extensions =  empty

field ::= text (#PCDATA)

36.1.2. Attributes

Additional attributes:

action
label
length
name
source
type

36.2. Description

A field is a generic element that can be used to mark up a unit of information in the contract that is either captured from the user, inserted from a database, generated by a processing application such as a cross reference tool, or extracted from the contract for other uses, such as to populate a contract-management database.

Specific functionality is not provided for the field element. The design of the element provides hooks to allow the application developer to implement functionality according to the requirements of a specific application.

Typically, this element would be used for generating space on a printed contract page where information, such as a date or signature, may be written. This may be rendered differently depending on the output format. For example, in a printed contract, a space may be rendered. In a web forms-based rendition, the field may be rendered as a text input box, allowing the user to type in a value.

An application will read the XML representation of the contract document to extract information. An example scenario would be a firm that leases products from many different firms. These firms provide the lease document in XML using this specification. The company's management information systems department writes an application to read each one and extracts the amount to be paid each month. This is used to update the accounts receivable and liabilities section of the general ledger program.

Another scenario would be a firm generating form contracts from database information. An apartment complex has a table containing for each apartment, the legal description of the apartment and the monthly rent. The contract XML would have field elements for each of these inputs. Again, their MIS department would write an application. In this case, it would look for the appropriate tuple in the database. It would replace the field elements by the corresponding fields or columns from that tuple.

36.2.1. Attributes

Common Attributes Class Attributes orient.attribute common.number.attribute

Additional attributes:

action: This is used to specify a statement relating to the type of processing action that may be applied to the field by processing applications.
label: This is for display purposes. For example, a form-based graphical-user interface program could display a text box for each field element it finds. The label attribute MAY be used to label this box so the user knows what to put there.
length: This is used to specify the length of the field when the field is used for data entry. This specification does not define the units of measurement. The units of measurement used are left to the application developer.
name: This is used to assign a name to the field for data extraction and processnig purposes. For example, if this application is extracting data from the contract and putting it in a database, the name may contain the name of the database column where the content of the field is extracted from or written to.
source: This is used to identify the source of the field information when the field is to be populated by a processing application. This could be a SQL or XPATH query.
type: This is used to indicate the data type of the field. This would typically be enumerated for a particular application. This specification does not define field data types. These are left to the application developer.

36.2.2. Parents

These elements contain field: address, citation, conditional, date, date-block, em, fallback, name, note-in-line, phrase, reference, statutory-em, strike, sub, subtitle, sup, term, terms, text and xi:fallback

36.2.3. Children

field can only contain text data (#PCDATA)

36.2.4. See Also

note, note-in-line, reference, party, phrase, and term.

36.2.5. Examples

Example B.13. The Payment Amount as a field.

<?xml version="1.0" encoding="utf-8"?>
<contract xmlns="urn:oasis:names:tc:eContracts:1:0"
          xmlns:dc="http://purl.org/dc/elements/1.1/"
          xmlns:xi="http://www.w3.org/2001/XInclude">

  <title><text>Sample of field</text></title>

  <body>
    <block>
      <text>In this licence:</text>
      <definition>
        <term>BNML Standard Schema</term>
        <block>
          <text>means the XML Schema called
Pay <field source="ida" name="PaymentAmount"></field>.
                .
          </text>
        </block>
      </definition>
    </block>
  </body>
</contract>

37. inclusion

37.1. Synopsis

37.1.1. Content Model


inclusion = element inclusion {

    metadata?, title?, inclusion.structure.model,
    inclusion.attlist

}


inclusion.structure.model = loose.structure.model


## Tight structure model
tight.structure.model = inclusion*,
                ((block, inclusion*)+ | (item.reuse.model+, inclusion*))?



## Standard structure model
standard.structure.model = inclusion*, (block, inclusion*)*,
                 (item.reuse.model+, inclusion*)


## Loose structure model
loose.structure.model = (block | inclusion | item.reuse.model)*


    item.reuse.model |= xiInclude

inclusion.attlist =
    common.attributes,
    inclusion.class.attribute,
    common.number.attribute,
    inclusion.align.attribute,
    orient.attribute,
    inclusion.numbering.attributes,
    inclusion.attlist.extensions


inclusion.numbering.attributes =    empty
inclusion.class.attribute =         standard.class
inclusion.align.attribute =         attribute align { ShortAlignment }?

inclusion.clear.attribute =
            [a:defaultValue = "both"]
            attribute clear { ClearEnumValues }?

ClearEnumValues = "left" | "right" | "both"


inclusion.width.attribute = attribute width { xsd:string }?
inclusion.attlist.extensions = empty

inclusion ::=

Sequence of
- Zero or one metadata
- Zero or more title .
- - If loose model is selected, sequence of:
    Zero or more of:
    block
    inclusion
    item
    xi:include
  - If standard model is selected, sequence of:
    Zero or more inclusion
    Zero or more sequences of
    One block
    Zero or more inclusion
    
    Sequence of
    One or more choice of
    item
    xi:include
    
    Zero or more inclusion
  - If tight structure model is selected, sequence of
    Zero or more of inclusion
    Zero or one of:
    One or more Sequences of
    One block
    Zero or more inclusion
    
    Sequence of
    One or more sequences of
    item
    xi:include
    
    Zero or more inclusion

37.1.2. Attributes

Additional Attributes:

align

37.2. Description

The inclusion element is a generic container element for content that is distinct from the narrative, such as quotations, annotations, notes and examples. It is also used to provide a title and number on graphical objects and tables.

Typically, the inclusion element contains content that is separate from the main contract provisions for automatic number of layout purposes.

By default, the inclusion uses the loose structure model. This model is very flexible and is able to mark up a variety of content that may not conform to regular structures and where a more strict structure is generally not necessary. The structure model used for the inclusion element may be changed to one of the other structure models as part of a customization.

37.2.1. Processing Expectations

Hierarchical content inside the inclusion should use a separate number sequence frmo the main contract hierarchy.

37.2.2. Attributes

Common Attributes Class Attributes orient.attribute common.number.attribute

Additional Attributes:

align

This is the horizontal alighment for content within the inclusion as given by ShortAlignment pattern:

Table B.5. (enumeration)

left	The content of the `inclusion` is left aligned.
center	The content of the `inclusion` is centered.
right	The content of the `inclusion` is right-aligned.

37.2.3. Parents

These elements contain inclusion: block entry attachment, back, block, inclusion and item

37.2.4. Children

The following elements occur inside inclusion: inclusion, item, metadata, item, xi:include

37.2.5. See Also:

object

37.2.6. Examples:

Example B.14. Two inclusion elements

<?xml version="1.0" encoding="utf-8"?>
<contract xmlns="urn:oasis:names:tc:eContracts:1:0"
          xmlns:dc="http://purl.org/dc/elements/1.1/"
          xmlns:xi="http://www.w3.org/2001/XInclude">

  <title><text>Sample of
               - item
               - num
               - block
               - inclusion
               - phrase
         </text></title>

  <body>

    <item number="2.1">

      <block number-type="none">

        <text>BNML Standard consists of 6 BNML specific files and
            2 files that incorporate external
            features into the application.
            The bnml-standard is the main file which includes all of the
            other files:</text>

        <inclusion class="code-listing">
          <block number-type="none">
            <text>/BNML Standard</text>
            <item>
              <block number-type="none">
                <text>/RelaxNG</text>
                <item>
                  <block>
                    <text>bnml-standard.rnc</text>
                    <text>bnml-document.rnc</text>
                    <text>bnml-contract.rnc</text>
                    <text>bnml-correspondence.rnc</text>
                    <text>bnml-core.rnc</text>
                    <text>bnml-structure.rnc</text>
                    <text>dc-metadata.rnc</text>
                    <text>xi-include.rnc</text>
                  </block>
                </item>
              </block>
            </item>
          </block>
        </inclusion>

        <inclusion class="example">
          <block>
            <text>
              <phrase class="code">bnml-s-application name.rnc</phrase>
            </text>
          </block>
        </inclusion>

      </block>

    </item>

  </body>

</contract>

38. item (outside of a block)

38.1. Synopsis

The item is the basic building block of the document hierarchy and represents structures that may have a title and a number. These may be known in documents as "chapters," "parts," "sections," "clauses" and "subclauses."

38.1.1. Content Model

item = element item {
    metadata?, title?, item.structure.model,
    item.attlist
}


item.structure.model = loose.structure.model
item.reuse.model = (item)


## Tight structure model
tight.structure.model = inclusion*,
                ((block, inclusion*)+ | (item.reuse.model+, inclusion*))?



## Standard structure model
standard.structure.model = inclusion*, (block, inclusion*)*,
                 (item.reuse.model+, inclusion*)


## Loose structure model
loose.structure.model = (block | inclusion | item.reuse.model)*

    item.reuse.model |= xiInclude

item.attlist =
    common.attributes,
    item.class.attribute,
    common.number.attribute,
    conditional.attributes,
    stop-contents.attribute,
    item.numbering.attributes,
    item.attlist.extensions


item.numbering.attributes =     empty
item.class.attribute =          standard.class
item.attlist.extensions =       empty

item ::=

Sequence of:
- Zero or one metadata
- If loose model is selected, sequence of:
  - Zero or more of:
    block
    inclusion
    item
    xi:include
- If standard model is selected, sequence of:
  - Zero or more inclusion
  - Zero or more sequences of
    One block
    Zero or more inclusion
  - Sequence of
    One or more choice of
    item
    xi:include
    
    Zero or more inclusion
- If tight structure model is selected, sequence of
  - Zero or more of inclusion
  - Zero or one of:
    One or more Sequences of
    One block
    Zero or more inclusion
    
    Sequence of
    One or more sequences of
    item
    xi:include
    
    Zero or more inclusion

Zero or one title

38.1.2. Attributes

Common Attributes Class Attributes condition.attribute Stop-Contents Attribute

38.2. Description

The item element is the basic building block of the contract hierarchy. It represents structures that may have a titile or a number. Commonly, such structures are known as provisions, sections, clauses and subclauses.

It also intended to represent items in a list. The TC was careful not to use a name for elements that maches any of that list so as to avoid confusion or biassing the reader's idea of how they might be used: [meyer03]. Please see item (inside a block) as item when it appears directly inside a block as a list item.

The item is intended to be the basic re-usable element that can be inserted almost anywhere in the document hierarchy.

The item element is typically added to an element's content models by using the item.reuse.model pattern, defined above. This pattern allows the content reuse features of the schema to be used in all content models where item occurs.

38.2.1. Processing expectations

If the stop-contents attribute is not used on a parent or ancestor element, the item's number and title SHOULD be presented in the table of contents. The item may be suppressed based upon its condition attribute.

38.2.2. Attributes

Common Attributes Class Attributes condition.attribute Stop-Contents Attribute

38.2.3. Parents

These elements contain item: attachment, back, block, inclusion and item

38.2.4. Children

The following elements occur inside item: inclusion item, metadata, item xi:include

39. item (inside a block)

39.1. Synopsis

This is the list item element.

39.1.1. Content Model



block = element block {
            (block.level.elements |
                    element item {
                        metadata?, title?, (block | inclusion)*,
                        block.item.attlist
                    }
              )*,

    block.attlist
}


block.level.elements = text.container.element | definition | table | inclusion
text.container.element = \text


block.attlist =
    common.attributes,
    block.class.attribute,
    conditional.attributes,
    block.numbering.attributes,
    block.attlist.extensions


block.numbering.attributes =
    block.number.type


block.class.attribute = standard.class
block.number.type =     attribute number-type { ListItemNumberTypes }?

ListItemNumberTypes =   "manual"
                      | "none"
                      | "disc"
                      | "line"
                      | "number"
                      | "loweralpha"
                      | "upperalpha"
                      | "lowerroman"
                      | "upperroman"

block.attlist.extensions = empty

item ::=

Sequence of
- Zero or one metadata
- Zero or more of
  - block
  - inclusion

39.1.2. Attributes

Common Attributes, Class Attributes and condition.attribute common.number.attribute

39.2. Description

Relax NG supports the ability to define an element with a different content model when it is directly under some other element. That is, it creates a context-sensitive grammar. See [sperberg] and [Relax]. This feature is used only once in the grammar for this specification, an item has a different definition inside a block than when it appears in other elements.

This is the list item element. The list element is redefined in the schema within the block context. This constrains the content model to allow only structures that would appear in list items.

39.2.1. Process Expectations

The list item should be numbered or marked according to the number-type attribute on the enclosing block element.

39.2.2. Attributes

Common Attributes, Class Attributes and condition.attribute

39.2.3. Parents

These elements contain a list item: block

39.2.4. Children

The following elements occur inside a list item: metadata, title, block and inclusion

39.2.5. See Also

item (outside of a block)

39.2.6. Examples

See body.

40. metadata

40.1. Synopsis

40.1.1. Content Model

metadata = element metadata {
    metadata.content,

    metadata.attlist
}

metadata.content = empty

metadata.attlist =
        common.attributes,
        metadata.attlist.extensions

metadata.attlist.extensions = empty


div {

    # add the condition attribute to all eContract elements.
    conditional.attributes &= condition.attribute
    inline.content.inner |= conditional

    # add the conditions structure to the metadata element
    metadata.content &=

        # define the conditions element and its children
        element conditions {

            element condition {
                text,

                attribute name { xsd:string },
                attribute default { xsd:boolean }?
            }+
        }?

}


    # add the condition attribute to all eContract elements.
    conditional.attributes &= condition.attribute
    inline.content.inner |= conditional

    # add the conditions structure to the metadata element
    metadata.content &=

        # define the conditions element and its children
        element conditions {

            element condition {
                text,

                attribute name { xsd:string },
                attribute default { xsd:boolean }?
            }+
        }?

metadata ::=

Zero or more instances of

40.1.2. Attributes

40.2. Description

This is a container for metadata. Metadata is currently defined to include a number of basic elements from the Dublin Core standard defined in dc-metadata.rnc [dc] and the conditions element.

It is intended that applications of the eContract schema will customize the metadata element to provide values that are applicable to that application.

40.2.1. Processing Expectations

The information in metadata tags SHOULD NOT be rendered in the normal narrative of the contract document. However, metadata values MAY be used in presentation, such as for page headers and footers.

40.2.6. Example

Example B.15. A metadata element showing several elements from the Dublin Core

<?xml version="1.0" encoding="utf-8"?>
<contract xmlns="urn:oasis:names:tc:eContracts:1:0"
          xmlns:dc="http://purl.org/dc/elements/1.1/"
          xmlns:xi="http://www.w3.org/2001/XInclude">

  <metadata>
    <dc:title>WIU CS Department notice 001</dc:title>
    <dc:creator>Julie Sasa</dc:creator>
    <dc:contributor>Keith Wallen</dc:contributor>
    <dc:subject>Scope of licence</dc:subject>
    <dc:publisher>WIU</dc:publisher>
    <!-- <dc:date>2005-09-20</dc:date> -->
    <dc:rights>Copyright, Elkera Pty Limited, 2005</dc:rights>
  </metadata>

  <title><text>Sample of metadata and its child elements</text></title>

  <body> </body>

</contract>

41. name

41.1. Synopsis

41.1.1. Content Model

name has a mixed content model.

name = element name {
    (inline.content | field)*,

    name.attlist
}


inline.content = (inline.content.inner)*
inline.content.inner = text | reference | em | statutory-em | strike | sub | sup | field

    inline.content.inner |= conditional

name.attlist =
        common.attributes,
        name.class.attribute,
        name.name.attribute,
        name.attlist.extensions

name.class.attribute =      standard.class
name.name.attribute =       attribute name { xsd:string }?
name.attlist.extensions =   empty

name :=

Zero or More of

41.1.2. Attributes

41.2. Description

This provides a text content for a name of a person, organization or company. It is often used in a party-record to mark up the name of the party to a contract.

41.2.1. Attributes

41.2.2. Parents

These elements contain name: date-block, person-record, and text

41.2.3. Children

The following elements occur inside name:

conditional, em, field, reference, statutory-em, strike, sub, sup

41.2.4. See Also:

address name

41.2.5. Examples

See address and parties

42. note

42.1. Synopsis

This is a footnote or endnote.

42.1.1. Content Model

note = element note {
    block+,

    note.attlist
}

note.attlist =
        common.attributes,
        note.class.attribute,
        common.number.attribute,
        note.attlist.extensions

note.class.attribute =      standard.class
note.attlist.extensions =   empty

note ::=

Sequence of
- One or more block

42.1.2. Attributes

Common Attributes , common.number.attribute and Class Attributes

42.2. Description

This is used for a foot note, end note or other type of note. These would be notes that are NOT rendered in line with its surrounding text.

42.2.1. Attributes

42.2.2. Parents

These elements contain note: date-block and text

42.2.3. Children

The following elements occur inside note: block

42.2.4. See Also

note-in-line

42.2.5. Example

Example B.16. Two notes and a note-in-line

<?xml version="1.0" encoding="utf-8"?>
<contract xmlns="urn:oasis:names:tc:eContracts:1:0"
          xmlns:dc="http://purl.org/dc/elements/1.1/"
          xmlns:xi="http://www.w3.org/2001/XInclude">

  <title><text>Sample of note and note-in-line.</text></title>

  <body>

    <block>
      <text>Send me a shirt.
             <note-in-line>standard size.</note-in-line></text>
    </block>

    <block>
      <text>Send me desks as listed below.
        <note number="1"><block><item></item></block></note>
        <note number="2"><block><item></item></block></note>
      </text>
    </block>

  </body>

</contract>

43. note-in-line

43.1. Synopsis

This is for notes that are kept inline with surrounding text.

43.1.1. Content Model

note-in-line has a mixed content model.

note-in-line = element note-in-line {
    inline.content,

    note-in-line.attlist
}


inline.content = (inline.content.inner)*
inline.content.inner = text | reference | em | statutory-em | strike | sub | sup | field

    inline.content.inner |= conditional
note-in-line.attlist =
        common.attributes,
        note-in-line.class.attribute,
        note-in-line.attlist.extensions

note-in-line.class.attribute =      standard.class
note-in-line.attlist.extensions =   empty

note-in-line ::=

Zero or More of

43.1.2. Attributes

43.2. Description

This is for notes that are kept inline with surrounding text.

43.2.1. Processing Expectations

This SHOULD be rendered so the text comprising the note-in-line can be easily distinguished from the other text surrounding it.

43.2.2. Attributes

note phrase reference

43.2.3. Parents

These elements contain note-in-line: address, citation, conditional, date, date-block, em, fallback, name, note-in-line, phrase, reference, statutory-em, strike, sub, subtitle, sup, term, terms, text and xi:fallback

43.2.4. Children

The following elements occur inside: note-in-line:

conditional, em, field, reference, statutory-em, strike, sub, sup

43.2.5. See Also

43.2.6. Examples

Example B.17. Two notes and a note-in-line

<?xml version="1.0" encoding="utf-8"?>
<contract xmlns="urn:oasis:names:tc:eContracts:1:0"
          xmlns:dc="http://purl.org/dc/elements/1.1/"
          xmlns:xi="http://www.w3.org/2001/XInclude">

  <title><text>Sample of note and note-in-line.</text></title>

  <body>

    <block>
      <text>Send me a shirt.
             <note-in-line>standard size.</note-in-line></text>
    </block>

    <block>
      <text>Send me desks as listed below.
        <note number="1"><block><item></item></block></note>
        <note number="2"><block><item></item></block></note>
      </text>
    </block>

  </body>

</contract>

44. object

44.1. Synopsis

44.1.1. Content Model

object = element object {
    data, fallback,

    object.attlist
}


object.attlist =
    common.attributes,
    object.type.attribute,
    object.scale.attribute,
    object.rotate.attribute,
    object.attlist.extensions


object.type.attribute =     attribute type { xsd:string }?
object.scale.attribute =    attribute scale   { xsd:string }?
object.rotate.attribute =   attribute rotate  { xsd:string }?

object.attlist.extensions = empty

object ::=

Sequence of
- data
- object

44.1.2. Attributes

Additional Attributes:

type
scale
rotate

44.2. Description

The object element is a container element for external objects such as images and other multimedia files.

An object can contain one data and one fallback element. The data element indicates the source of the object and the fallback element contains the fallback position if a particular application cannot render the object.

The type attribute MUST be a MIME content type (e.g. image/png), and the data element MUST point to a valid location from which the object may be accessed.

44.2.1. Processing Expectations

The data element indicates the source of the object, e. g. a file name or URL. It is possible that the application may not be able to locate the object or may not be able to render it once reached. For example, the application may not know how to deal with a format or the network may fail or the object data might be corrupted. If so, the fallback contains the item or text to be displayed. As discussed under fallback, this may be a cascading or recursive set of fallbacks.

44.2.2. Attributes

Additional Attributes:

rotate: This is used to rotate the object. This attribute typically contains the degrees of anti-clockwise rotation applied to the object.
scale: This is used to scale the object. This specification does not state how this should be written.
type: This specifies the MIME type of the object, e. g. Image/Jpeg or Audio/Basic [Grand93]

44.2.3. Parents

These elements contain object: address, date, em, fallback, field, name, note, note-in-line, object, party, person-record, phrase, reference, statutory-em, strike, sub, sup, term

44.2.4. Children

The following elements occur inside object: data and fallback

44.2.5. Example

Please see fallback.

45. parties

45.1. Synopsis

The parties element contains the parties to the contract.

45.1.1. Content Model

parties = element parties {

    title?, party+,

    parties.attlist
}


parties.attlist =
    common.attributes,
    parties.class.attribute,
    parties.attlist.extensions


parties.class.attribute =    standard.class
parties.attlist.extensions = empty

parties ::=

Sequence of
- Zero or one title
- One or more party

45.1.2. Attributes

45.2. Description

The parties contains the parties to the contract.

In some jurisdictions, such as Australia, New Zealand and the UK, it is common to layout the parties to a contract on separate lines under a Parties title. For example:

This agreement is made on the ___ day of ___

between the

first party (short-name)

and

second party (short-name)

[crc], [harrop03], [oxford].

In US contracts, this is not so common. In the US cases, the parties element may not be required. For example:

This contract is made and entered into between first party, hereinafter referred to as "short-name" and second party, hereinafter referred to as "short-name"

Or taking the form from the American Institute of Architects standard contract:

AGREEMENT made as of the day of in the year

BETWEEN the short-name:

name and address

and the short-name:

name and address[ aia]

the short-name is then used throughout the contract. For example, one might write that "Acme Business Systems, Inc." would be referred to as "the Company" hereinafter.

The party element may be used directly inside block for US contracts.

45.2.1. Processing Expectations

The title SHOULD appear at the top with the information for each party on a separate line.

Below is an example of how the front might look for such a contract. Please note that this does NOT match any of the xml examples provided:

Party

45.2.2. Attributes

45.2.3. Parents

These elements contain parties: contract-front

45.2.4. Children

The following elements occur inside parties: title and party

45.2.5. See Also

party

45.2.6. Examples

Example B.18. Parties Example

<?xml version="1.0" encoding="utf-8"?>
<contract xmlns="urn:oasis:names:tc:eContracts:1:0"
          xmlns:dc="http://purl.org/dc/elements/1.1/"
          xmlns:xi="http://www.w3.org/2001/XInclude">

  <title><text>
Sample of :
               - contract-front
               - parties
               - party
               - person-record
               - name
               - address
               - background
  </text></title>

<contract-front>

<date-block>Agreement dated:
    <field class="date" type="blank" name="contract_date" length="75mm">
<?xm-replace_text {ec:field}?></field></date-block>
<parties><title><text>Parties</text></title>
    <party><person-record><name>ABC Ventures Limited</name> having
            its office at <address>100 Main Street, Sydney, NSW 2000</address>
           </person-record>, hereafter referred to as
                 "<term>General Partner</term>"
    </party>
    <party><person-record><name>John A. Doe</name> of
            <address>10 Ramrod Drive, Sydney, NSW 2000</address></person-record>
              and <person-record><name>John W. Smith</name> of
          <address>25 Pine Road, Plainsville, NSW, 0000</address>
            </person-record>, herafter collectively referred to as
                  "Limited Partners"
    </party>
</parties>
<background><title><text>Background</text></title>
    <item number="A">
      <block><text>This is the text of the first recital</text></block>
    </item>
    <item number="B">
      <block><text>Text of the second recital</text></block>
    </item>
</background>

</contract-front>

<body></body>

</contract>

Remember that this does NOT match the picture above.

46. party

46.1. Synopsis

This is a party to the contract.

46.1.1. Content Model

party has a mixed content model.


party = element party {

    (text | person-record | term)*,

    party.attlist
}


party.attlist =
    common.attributes,
    party.class.attribute,
    party.attlist.extensions


party.class.attribute =    standard.class
party.attlist.extensions = empty

party ::=

Zero or More of

46.1.2. Attributes

46.2. Description

The party element is used to contain the details of each party to the contract.

A party may occur inside the parties element or it may occur inside a text element.

Within the party element, the details such as name and address of each person or entity in the party are captured using the person-record element.

46.2.1. Attributes

46.2.2. Parents

These elements contain party: date-block parties text

46.2.3. Children

The following elements occur inside party: text, person-record and term

46.2.4. See Also

name address

46.2.5. Example

See parties

47. party-signature

47.1. Synopsis

party-signature -- Place where a signature or seal will be applied to the contract document.

47.1.1. Content model

party-signature = element party-signature {

    (block*, ( signatory-group | signatory-record ), block*),

    party-signature.attlist
}


party-signature.attlist =
    common.attributes,
    party-signature.layout.attribute,
    party-signature.party-id.attribute,
    party-signature.attlist.extensions


party-signature.layout.attribute =
    [a:defaultValue = "from-left"]
    attribute layout { party-signature.layout.values }?

party-signature.layout.values = "right-column-only" | "from-left"

party-signature.party-id.attribute = attribute party-id { xsd:string }?
party-signature.attlist.extensions = empty

party-signature ::=

Sequence of
- Zero or more block
- One of
  - signatory-group
  - signatory-record
- Zero or more block

47.1.2. Attributes

Additional attributes:

layout(enumeration)
- "from-left"
- "right-column-only"
party-id

47.2. Description

This is the place for markup for what would be considered a signature. In the case, where this is rendered to a physical document, this is where a person would apply a "pen-and-ink" signature and/or affix a seal. There will be sets of signatures, for example, a signatory and witness or two partners or officers of the same company

The party-signature markup provides a semantic representation of the components needed to render complex signature provisions in contracts. It also includes some presentational characteristics. If this complexity is not required, signature provisions may be created by using tables and the signature-line element.

47.2.1. Processing Expectations

If align-records is horizontal, then the signatures will be rendered in multiple columns, usually two. If set to vertical, then they will be rendered vertically.

47.2.2. Attributes

layout

Table B.6. (enumeration)

right-column-only	The page is divided into two columns. Render the signature in the right column.
from-left	render signatures from the left page margin.
party-id

47.2.3. Parents

These elements contain party-signature: back

47.2.4. Children

The following elements occur in party-signature: block, signatory-group, signatory-record

47.2.5. Examples

The following example consists of a single signatory-record containing both a signatory-record and a witness within the party-signature record:

Example B.19. A single signer plus a witness

<?xml version="1.0" encoding="utf-8"?>
<contract xmlns="urn:oasis:names:tc:eContracts:1:0"
          xmlns:dc="http://purl.org/dc/elements/1.1/"
          xmlns:xi="http://www.w3.org/2001/XInclude">

  <title><text>Sample of :
               - back
               - party-signature
               - signatory-group
               - signatory-record
               - signatory
               - signatory-line
  </text></title>

  <body></body>

  <back>

    <party-signature>

      <signatory-group>

        <block> </block>

        <signatory-record>

          <signatory id="T0001" xml:lang="ja">
            <signature-line id="I0001" xml:lang="en_US">
              <text>Mr. Signatory Jr.</text>
              <field>Field for a text.</field>
            </signature-line>
          </signatory>

          <witness>
            <signature-line id="I0002" xml:lang="fr">
              <text>Ms. Witness Arcole</text>
              <field>Field for a text.</field>
            </signature-line>
          </witness>

        </signatory-record>

      </signatory-group>

    </party-signature>

  </back>

</contract>

A simple party signature by John Doe is here. Observe the initial block to give the text "Signed by John Doe" A signatory-record, signatory and signature-line

Example B.20. A single person signing

<party-signature> <block><text>Signed by <name class="person">John W.
Doe</name></text></block><signatory-record><signatory><signature-line>
<field type="blank" length="50"/> <text>John W.
Doe</text></signature-line></signatory> </signatory-record></party-signature>

When there are two persons signing for one party, there are two signature-line tags within one signature-group:

Example B.21. Two Partners or officers of the same company

<party-signature> <block><text>Signed by the Limited
Partners</text></block><signatory-group align-records="horizontal">
<signatory-record><signatory><signature-line><field type="blank" length="50"/>
   <text>John A Doe</text>
   <text>Partner</text></signature-line></signatory>
</signatory-record><signatory-record><signatory><signature-line>
<field type="blank" length="50"/>
<text>John W.  Smith</text><text>Partner</text></signature-line></signatory>
</signatory-record></signatory-group></party-signature>

Observe the align-record= horizontal which forces both Mr. Doe and Mr. Smith's signature lines to be side by side.

Similarly, one can include a witness element in a signatory-record:

Example B.22. A signatory and a witness

<party-signature><block><text>Signed by John W. Smith in the presence
of:</text></block>
<signatory-record align-signatory-witness="horizontal">
<witness><signature-line><field type="dotleader" length="50"/>
<text>Witness</text></signature-line></witness><signatory>
<signature-line><field type="dotleader" length="50"/><text>John W.
Smith</text></signature-line></signatory></signatory-record></party-signature>

Observe the align-signatory-witness attribute which appears on the signatory-record. Here is a similar example, but where the align-signatory-witness attribute is specified to be vertical:

Example B.23. Illustration of align-signatory-witness

<party-signature><block><text>Signed by John W.
Smith:</text></block><signatory-record align-signatory-witness="vertical">
<signatory><signature-line><field type="dotleader" length="50"/>
<text>John W.  Smith</text></signature-line></signatory>
<witness><signature-line><field type="dotleader" length="50"/>
   <text>Witness</text></signature-line></witness>
</signatory-record></party-signature>

The user may put the attribute, layout="right-column-only" on the party-signature to have several lines of text as well as the place where the user will sign lined up on the right side of the page:

Example B.24. Right-column-only illustration

<party-signature layout="right-column-only"><block>
<text>Accepted and agreed:</text></block><block>
<text>Signed on behalf of XYZ Corporation Limited,
by John W. Smith, its authorized director:</text></block>
<signatory-record><signatory><signature-line>
   <field length="50" type="dotleader"/><text>John W.  Smith</text>
   <text>Director</text></signature-line></signatory>
</signatory-record></party-signature>

This example shows the use of the brace attribute on the signatory-record:

Example B.25. The brace attribute

<party-signature> <signatory-group align-records="vertical" brace="block-only">
<block><text>Signed, sealed and delivered on behalf of XYZ Corporation Limited
by two of its directors:
</text></block><signatory-record align-signatory-witness="horizontal">
<witness> <signature-line><field type="dotleader" length="50"/>
<text>Signature of
witness</text></signature-line><signature-line><field type="dotleader"
length="50"/><text>Name of witness</text></signature-line>
</witness><signatory><signature-line><field type="dotleader" length="50"/>
    <text>John W.  Smith</text></signature-line></signatory></signatory-record>
<signatory-record align-signatory-witness="horizontal">
<witness> <signature-line><field type="dotleader" length="50"/>
<text>Signature of witness</text></signature-line>
<signature-line>
   <field type="dotleader" length="50"/><text>Name of witness</text>
</signature-line></witness>
<signatory><signature-line><field type="dotleader" length="50"/>
    <text>John A.  Doe</text></signature-line></signatory>
</signatory-record></signatory-group>
</party-signature>

signatory-record's can be nested to show delegation. This is rendered by a small indentation for the information within the nested signatory-record.

Example B.26. Nested signatory-records to show delegation.

<block><text>This is a signature block with a nested record:</text></block>
<party-signature layout="right-column-only">
<block><text>"Lender"</text></block>
<block><text>Roadway Finance Company,</text>
       <text>a Delaware limited company</text></block>
<signatory-record><block>
   <text>By: XYZ Limited Partnership,</text>
   <text>a Delaware limited partnership, its sole member</text></block>
<signatory-record> <block><text>By: XYZ Office Properties Trust,</text>
       <text>a Delaware real estate investment trust,
             its general partner</text></block>
<signatory-record><signatory>
   <signature-line><text>By: /s/ John A. Doe</text>
         <field length="50" type="blank"/>
   </signature-line>
   <block><text>Name: John A. Doe</text></block>
   <block><text>Title: Senior Vice President</text></block>
</signatory></signatory-record></signatory-record></signatory-record>
<block><text></text></block><block>
       <text>1000 North Riverside Plaza</text>
       <text>Chicago, IL 60606</text>
       <text>Attention: General Counsel</text></block>
</party-signature>

48. person-record

48.1. Synopsis

This is used to contain information about a person or other entity.

48.1.1. Content Model

person-record has a mixed content model.


person-record = element person-record {

    (text | name | address | field | term)*,

    person-record.attlist
}


person-record.attlist =
    common.attributes,
    person-record.class.attribute,
    person-record.party-id.attribute,
    person-record.attlist.extensions


person-record.class.attribute =     standard.class
person-record.party-id.attribute =  attribute party-id { xsd:string }?
person-record.attlist.extensions =  empty

person-record ::=

Zero or more

48.1.2. Attributes

Common Attributes Common Attributes

Additional attributes:

party-id

48.2. Description

The person-record element is used to capture the details of a person or other entity that is a party to the contract. It may also be used to describe any person who is referenced in the contract, such as an attorney under a power of attorney.

Normally, a person-record would be contained within a party element. However, in some US-style contracts, the person's details may be broken up so it is not possible to capture all details within a single party element and still maintain semantic integrity of the markup and grammatical integrity of the sentence. For situations where the person's details cannot be captured within a single party element, the person-record element is allowed to occur inside the text element.

When a person-record element is not used within a party element, the person-record's party-id attribute is used to reference the party to which the record relates.

48.2.1. Attributes

Additional Attributes:

party-id: This is used to associate a person-record with a party element when the person-record needs to be created outside the party element.

48.2.2. Parents

These elements contain person-record: date-block, party, and text

48.2.3. Children

The following elements occur inside person-record: address, field, name and term

48.2.4. See Also

party

48.2.5. Examples

See parties

49. phrase

49.1. Synopsis

49.1.1. Content Model

phrase has a mixed content model.

phrase = element phrase {
    inline.content,

    phrase.attlist
}



inline.content = (inline.content.inner)*
inline.content.inner = text | reference | em | statutory-em | strike | sub | sup | field

    inline.content.inner |= conditional
phrase.attlist =
        common.attributes,
        phrase.class.attribute,
        phrase.attlist.extensions


phrase.class.attribute =    standard.class
phrase.attlist.extensions = empty

phrase ::=

Zero or more of

49.1.2. Attributes

49.2. Description

This might be used on something for which emphasis is placed in rendering. It may be used to explain something outside the normal flow of text. It may be a technical or foreign word.

49.2.1. Processing Expectations

This is rendered inline. Typically, it would be rendered differently so as to give emphasis, possibly as indicated by class attribute.

49.2.2. Attributes

49.2.3. Parents

The following elements occur inside phrase: address, citation, conditional, date, date-block, em, fallback, name, note-in-line, phrase, reference, statutory-em, strike, sub, subtitle, sup, term, terms, text and xi:fallback

49.2.4. Children

The following elements occur inside phrase:

conditional, em, field, reference, statutory-em, strike, sub, sup

49.2.5. See Also

note and note-in-line

50. reference

50.1. Synopsis

50.1.1. Content Model

reference = element reference {
    (inline.content | citation)*,

    reference.attlist
}


inline.content = (inline.content.inner)*
inline.content.inner = text | reference | em | statutory-em | strike | sub | sup | field

    inline.content.inner |= conditional
reference.attlist =
    common.attributes,
    reference.class.attribute,
    reference.href.attribute,
    reference.print-url.attribute,
    reference.attlist.extensions


reference.class.attribute =     standard.class
reference.href.attribute =      attribute href { xsd:anyURI }?
reference.print-url.attribute = attribute print-url { xsd:boolean }?

reference.attlist.extensions = empty

    reference.attlist &= attribute destination-type { xsd:string }?
    reference.attlist &= attribute destination-lang { xsd:string }?

reference ::=

Zero or more of

50.1.2. Attributes

Additional attributes:

destination-lang
destination-type
href
print-url

50.2. Description

A reference is a word or phrase which refers to another resource, whether internal or external to the contract. Typically, it is used for cross references and citations to other works.

50.2.1. Processing Expectations

The content of this element is rendered inline.

50.2.2. Attributes

citation em field reference statutory-em strike sub sup

Additional Attributes:

destination-type

This attribute indicates the type of resource that is referenced. This attribute is provided to support the WAI Web Content Accessibility Guidelines.

destination-lang

This attribute indicates the lagnuage of the resource that is referenced. This attribute is provided to support the WAI Web Content Accessibility Guidelines.

href

This specifies the URL or other way of finding the object, as one would write it in HTML

print-url

This is used to control rendering of the references to external web sites in print outputs. For example: <reference href="http://www.oasis-open.org/committees/documents.php?wg_abbrev= legalxml-econtracts">This specification</reference> In print output, it might be desirable to be able to output this as:

This specification
(www.oasis-open.org/committes/documents.php?wg_abbrev=legalxml-econtracts)

50.2.3. Parents

These elements contain reference: address, citation, conditional, date, date-block, em, fallback, name, note-in-line, phrase, reference, statutory-em, strike, sub, subtitle, sup, term, terms, text and xi:fallback

50.2.4. Children

The following elements occur inside reference:

50.2.5. See Also

term

50.2.6. Examples

Example B.27. Shows one reference element with print-url true

<?xml version="1.0" encoding="utf-8"?>
<contract xmlns="urn:oasis:names:tc:eContracts:1:0"
          xmlns:dc="http://purl.org/dc/elements/1.1/"
          xmlns:xi="http://www.w3.org/2001/XInclude">

  <title><text>Sample of
               - attachments
               - attachment
               - title
               - block
               - text
  </text></title>

  <body></body>

  <attachments>
    <attachment class="appendix" id="a1" number="15">
      <title><text>Form of notice in Schema files</text></title>
      <block><text>They must be sent regular mail.</text></block>
      <block><text>Standard Schema
          <reference href="http://www.elkera.com" print-url="true">
can be read on the web easily!</reference>.</text></block>
    </attachment>
 </attachments>

</contract>

51. row

51.1. Synopsis

This is a table row.

51.1.1. Content Model

row = element row {
    entry+,

    row.attlist
}

row.attlist =
    common.attributes,
    attribute rowsep  { xsd:boolean }?,
    attribute valign  { TableValign }?,
    row.attlist.extensions

TableValign = "top" | "middle" | "bottom"

row.attlist.extensions = empty

row ::=

One or more
- entry

51.1.2. Attributes

Additional Attributes:

rowsep
valign

51.2. Description

A row in a table. This element and all other elements contained by table are taken from the OASIS Exchange Table Model. Please refer to that specification for full details of this element. [table1],[table2].

51.2.1. Attributes

This section only provides a brief description of each attribute's purpose. Please refer to the OASIS Exchagne Table Model for details and processing semantics of these attributes: Common Attributes

Additional Attributes:

rowsep

This controls the display of the row separator underneath this cell in the table.

valign

The vertical alignment of the table row.

Table B.7. (enumeration)

`top`	Align the content at the top of the row.
`middle`	Align the content within the row.
`bottom`	Align the content at the bottom of the row.

51.2.2. Parents

These elements contain row: thead and tbody.

51.2.3. Children

The following element occur inside row: entry

51.2.3.1. Example:

Please see table.

52. signatory

52.1. Synopsis

A signatory is a person who signs a contract or document.

52.1.1. Content Model

signatory = element signatory {

    (signature-line | block)*,

    signatory.attlist
}

signatory.attlist =
    common.attributes,
    signatory.person-record-id.attribute,
    signatory.attlist.extensions


signatory.person-record-id.attribute = attribute person-record-id { xsd:string }?
signatory.attlist.extensions = empty

signatory ::=

Zero or more of
- signature-line
- block

52.1.2. Attributes

Additional Attributes

person-record-id

52.2. Description

This provides the blank line and printed information for a person who signs a contract.

52.2.1. Attributes

Additional Attributes:

person-record-id: This allows the signatory to be associated with a person-record element that contains more information about the signatory.

52.2.2. Parents

The elements contain signatory: signatory-record

52.2.3. Children

The following elements occur inside: signatory

signature-line and block

52.2.4. See Also

witness

52.2.5. Examples

Please see party-signature for extensive examples.

Example B.28. Shows use of person-record-id

<?xml version="1.0" encoding="utf-8"?>
<contract xmlns="urn:oasis:names:tc:eContracts:1:0"
          xmlns:dc="http://purl.org/dc/elements/1.1/"
          xmlns:xi="http://www.w3.org/2001/XInclude">
<title><text>Showinging person-record-id</text></title>
<contract-front>
<parties>
<party><person-record id="AA2"><name>John Smith</name>
</person-record>
 and <person-record id="AA3"><name>Jaime Velazquez</name></person-record></party>
</parties></contract-front>
<body><block><text>Empty Body</text></block></body>
<back><party-signature>
<signatory-group>
<signatory-record>
<signatory id="T001" xml:lang="en" person-record-id="AA2">
          <signature-line><text>Mr. John Smith</text><field>___</field></signature-line>
</signatory>
<signatory id="T002" xml:lang="en" person-record-id="AA3">
<signature-line><text>Ms. Jaime Velazquez</text><field>___</field></signature-line>
</signatory>
</signatory-record>
</signatory-group>
</party-signature>
</back>
</contract>

53. signatory-group

53.1. Synopsis

53.1.1. Content Model


signatory-group = element signatory-group    {

    (block*, signatory-record+),

    signatory-group.attlist
}


signatory-group.attlist =
    common.attributes,
    signatory-group.align-records.attribute,
    signatory-group.brace.attribute,
    signatory-group.attlist.extensions


signatory-group.align-records.attribute =
    attribute align-records { signatory-group.align-records.values }?

signatory-group.align-records.values = "horizontal" | "vertical"

signatory-group.brace.attribute =
    attribute brace  { signatory-group.brace.values }?

signatory-group.brace.values = "block-only"

signatory-group.attlist.extensions = empty

signatory-group ::=

Sequence of
- block
- One or more signatory-record

53.1.2. Attributes

Additional attributes:

align-records(enumeration)
- "horizontal"
- "vertical"

53.2. Description

This represents a group of related signatures, e. g., several officers for the same corporation or a witness and a signature. These are represented as the signature and witness tags, respectively.

A signatory-group is used where several persons must sign on behalf of a party, such as to attest the fixing of a common seal or for partners in a partnership.

53.2.1. Processing Expectations

The signature information will be aligned across the page if align-records is horizontal or vertically if specified as vertical. A brace or thick line will be to the right of the signatures if the brace is specified.

53.2.2. Attributes

Common Attributes Additional Attributes:

align-records. This specifies how signatory-records are aligned with the signatory-group. This attribute can have the following values:
Table B.8. (enumeration)
"horizontal"
The information for this signature group SHOULD be layed out across the page.
"vertical"
The information for this signature group SHOULD be layed out underneath each other.
brace This specifies that a brace (or thick column separator) is rendered to the right of the content in the left column. This is ignored when the layout attribute for party-signature is right-column-only
Table B.9. (enumeration)
"block-only"
A brace or thick column separator is rendered to the right of the content in the left column.

53.2.3. Parents

These elements contain signatory-group: party-signature.

53.2.4. Children

The following elements occur inside signatory-group: block and signatory-record

53.2.5. See Also

signatory-record

53.2.6. Examples

See party-signature

54. signatory-record

54.1. Synopsis

54.1.1. Content Model

signatory-record = element signatory-record  {

    (block*,
        (signatory-record |
            ((signatory+, witness*) | (witness+, signatory))
        ),
    block*),

    signatory-record.attlist
}


signatory-record.attlist =
    common.attributes,
    signatory-record.align-signatory-witness.attribute,
    signatory-record.brace.attribute,
    signatory-record.attlist.extensions


signatory-record.align-signatory-witness.attribute =
    attribute align-signatory-witness { align-signatory-witness.values }?

align-signatory-witness.values = "horizontal" | "vertical"

signatory-record.brace.attribute =
    attribute brace { brace.values }?

brace.values = "block-only"

signatory-record.attlist.extensions = empty

signatory-record ::=

Sequence of
- block
- Choice of
  - signatory-record
    Choice of
    Sequence of
    One or more signatory
    Zero or more witness
    
    Sequence of
    One or more witness
    One signatory
    
    Zero or more block

54.1.2. Attributes

Additional attributes:

align-signatory-witness (enumeration)
- "horizontal"
- "vertical"
brace(enumeration)
- "block-only"

54.1.3. Additional Constraints

brace is ignored when contained the enclosing party-signature specified layout as right-column-only or if enclosed within a signatory-group element.

54.2. Description

This is used to bind one or more signatories as well as a possible witness. Its content can be in three forms:

A single signatory-record. This is used for sub-delegations.
One or more signatory elements. These may be followed by witness. The multiple signatory records reflect several people signing on behalf of one party.
One or more witness records followed by a signatory record. (See the third example under party-signature.)

The signatory-record can be used recursively or as a flat model. The recursive model allows nested signature-record elements for complex signatures with sub-delegations. This is used in US contracts.

54.3. Processing Expectations

If one has signatory-record nested, then the inner one, representing a subdelegation, would be nested. See the last screen shot in party-signature.

If a align-signatory-witness is horizontal the information in the signatory-record is laid out horizontally. If vertical, then the information is laid out one under another. Please look at the second and third example under party-signature.

If brace is block-only, then there will be a brace or thick colun separator to the right of the left column's content. See the second to last example under party-signature.

54.4. Attributes

Additional Attributes:

align-signatory-witness

This indicates whether the witness and signatorys arranged by row or vertically within each defined by the signatory-record element. This attribute can have the following values:

Table B.10. (enumeration)

horizontal	The signature information is laid out across the page.
vertical	The signature inforamtion is laid out vertically, with one item underneath another

brace

This specifies that a brace (or thick column separator) is rendered to the right of the content in the left column. This attribute is ignored when the layout attribute for a party-signature is right-column-only.

Table B.11. (enumeration)

"horizontal"	The signature information is laid out across the page.
"vertical"	The signature information is laid out with one item underneath another.

54.5. Parents

These elements contain signatory-record: party-signature, signatory-group, and signatory-record

54.6. Children

The following elements occur inside signatory-record: block, signatory, signatory-record and witness

54.7. See Also

signatory

54.8. Examples

See party-signature

55. signature-line

signature-line creates the line on which a pen-and-ink signature is applied.

55.1. Synopsis

55.1.1. Content Model

signature-line = element signature-line {

   (\text* & field )*,

    signature-line.attlist
}

signature-line.attlist =
    common.attributes,
    signature-line.attlist.extensions

signature-line.attlist.extensions = empty

signature-line ::

Zero or more interleave of
- text
- field

55.1.2. Attributes

55.2. Description

This creates the line on which a pen-and-ink signature may be written on a printed document.

55.2.1. Attributes

55.2.2. Parents

These elements contain signature-line: entry signatory and witness

55.2.3. Children

The following elements occur inside signature-line: text and field

55.2.4. Examples

Please see party-signature for extensive examples.

56. statutory-em

56.1. Synopsis

56.1.1. Content Model

statuory-em has a mixed content model.

statutory-em = element statutory-em {
    inline.content,

    statutory-em.attlist
}


inline.content = (inline.content.inner)*
inline.content.inner = text | reference | em | statutory-em | strike | sub | sup | field

    inline.content.inner |= conditional

statutory-em.attlist =
        common.attributes,
        statutory-em.class.attribute,
        statutory-em.attlist.extensions

statutory-em.class.attribute =    standard.class
statutory-em.attlist.extensions = empty

statutory-em ::=

Zero or more of

56.1.2. Attributes

56.2. Description

This is used to mark up content that must be emphasized as per a particular statute. Presumably, the application program will render the contract emphasizing the text as required by that statute. The TC recognized this need in [Min0216].

56.2.1. Attributes

56.2.2. Parents

These elements contain statutory-em: address, citation, conditional, date, date-block, em, fallback, name, note-in-line, phrase, reference, statutory-em, strike, sub, subtitle, sup, term, terms, text and xi:fallback

56.2.3. Children

The following elements occur inside: statutory-em:

conditional, em, field, reference, statutory-em, strike, sub, sup

56.2.4. See Also

em strike

56.2.5. Examples

Example B.29. Statutory-em Example

<contract xmlns="urn:oasis:names:tc:eContracts:1:0"
          xmlns:dc="http://purl.org/dc/elements/1.1/"
          xmlns:xi="http://www.w3.org/2001/XInclude">

  <title><text>Sample of inline elements</text></title>

  <body>
    <block>
      <text>The location to deliver <em>the item</em>
    <strike>has to be one of <statutory-em>designated
    terminals.</statutory-em></strike> will be any places.</text>
    </block>
  </body>

</contract>

57. strike

57.1. Synopsis

57.1.1. Content Model

strike has a mixed content model.

strike = element strike {
    inline.content,

    strike.attlist
}


inline.content = (inline.content.inner)*
inline.content.inner = text | reference | em | statutory-em | strike | sub | sup | field

    inline.content.inner |= conditional

strike.attlist =
    common.attributes,
    strike.attlist.extensions

strike.attlist.extensions = empty

strike ::=

Zero or more of

57.1.2. Attributes

57.2. Description

This is used to markup text that is to be struck through. This is commonly used to indicate changes between versions of documents.

57.2.1. Attributes

57.2.2. Parents

These elements contain strike: text

57.2.3. Children

The following elements occur inside strike:

conditional, em, field, reference, statutory-em, strike, sub, sup

57.2.4. See Also

sub sup

57.2.5. Examples

Example B.30. Example of the strike element

<?xml version="1.0" encoding="utf-8"?>
<contract xmlns="urn:oasis:names:tc:eContracts:1:0"
          xmlns:dc="http://purl.org/dc/elements/1.1/"
          xmlns:xi="http://www.w3.org/2001/XInclude">

  <title><text>Sample of inline elements</text></title>

  <body>
    <block>
      <text>The location to deliver <em>the item</em>
    <strike>has to be one of <statutory-em>designated
    terminals.</statutory-em></strike> will be any places.</text>
    </block>
  </body>

</contract>

58. sub

58.1. Synopsis

58.1.1. Content Model

sub has a mixed content model:

sub = element sub {
    inline.content,

    sub.attlist
}

inline.content = (inline.content.inner)*
inline.content.inner = text | reference | em | statutory-em | strike | sub | sup | field

    inline.content.inner |= conditional
sub.attlist =
    common.attributes,
    sub.attlist.extensions

sub.attlist.extensions = empty

sub ::=

Zero or more of

58.1.2. Attributes

58.2. Description

This is used to mark up content to be subscripted.

58.2.1. Attributes

58.2.2. Parents

These elements cotnain sub: address, citation, conditional, date, date-block, em, fallback, name, note-in-line, phrase, reference, statutory-em, strike, sub, subtitle, sup, term, terms, text and xi:fallback

58.2.3. Children

The following elements occur inside sub:

conditional, em, field, reference, statutory-em, strike, sub, sup

58.2.4. See Also

sup strike

58.2.5. Examples

Example B.31. Example of sub and sup elements

<?xml version="1.0" encoding="utf-8"?>
<contract xmlns="urn:oasis:names:tc:eContracts:1:0"
          xmlns:dc="http://purl.org/dc/elements/1.1/"
          xmlns:xi="http://www.w3.org/2001/XInclude">

  <title><text>Sample of sub and sup</text></title>

  <body>
    <block>
      <text>The Elkera<sup>3</sup> Business Narrative
Markup Language (BNML<sup>1</sup>)</text>
    </block>
    <block>
      <text>A<sub>10</sub></text>
    </block>
  </body>

</contract>

59. subtitle

59.1. Synopsis

59.1.1. Content Model

subtitle has a mixed content model.

subtitle = element subtitle {
    inline.content,

    subtitle.attlist
}
inline.content = (inline.content.inner)*
inline.content.inner = text | reference | em | statutory-em | strike | sub | sup | field

    inline.content.inner |= conditional
subtitle.attlist =
    common.attributes,
    subtitle.attlist.extensions

subtitle.attlist.extensions = empty

subtitle ::=

Zero or More of

59.1.2. Attributes

59.1.3. Description

This contains a secondary title for the parent structure. The subtitle is usually intended to further explain the title.

59.1.3.1. Attributes

59.1.4. Parents

These elements contain subtitle: attachment and contract

59.1.5. Children

The following elements occur inside subtitle: text

59.1.6. See Also:

title

59.1.7. Examples

Example B.32. Example of a subtitle element

<?xml version="1.0" encoding="utf-8"?>
<contract xmlns="urn:oasis:names:tc:eContracts:1:0"
          xmlns:dc="http://purl.org/dc/elements/1.1/"
          xmlns:xi="http://www.w3.org/2001/XInclude">

  <title><text>Subtitle Example </text></title>
  <subtitle>Here is a <em>subtitle</em> for this subcontract
    eContracts specifcation draft
  </subtitle>





  <body></body>

  <back></back>

  <attachments>

    <attachment><title><text>Attachment Title</text></title><subtitle>Attachment
Subtitle</subtitle><subtitle>More than One Subtitle
Allowed</subtitle></attachment>
  </attachments>

</contract>

60. sup

60.1. Synopsis

60.1.1. Content Model

sup has a mixed content model.

sup = element sup {
    inline.content,

    sup.attlist
}


inline.content = (inline.content.inner)*
inline.content.inner = text | reference | em | statutory-em | strike | sub | sup | field

    inline.content.inner |= conditional

sup.attlist =
    common.attributes,
    sup.attlist.extensions

sup.attlist.extensions = empty

sup ::=

Zero or More of

60.1.2. Attributes

60.2. Description

This is used to markup text that is to be superscripted.

60.2.1. Attributes

60.2.2. Parents

These elements contain sup: address, citation, conditional, date, date-block, em, fallback, name, note-in-line, phrase, reference, statutory-em, strike, sub, subtitle, sup, term, terms, text and xi:fallback

60.2.3. Children

The following elements occur inside sup:

conditional, em, field, reference, statutory-em, strike, sub, sup

60.2.4. See Also

sub strike

60.2.5. Examples

Example B.33. Example showing the sub and sup elements

<?xml version="1.0" encoding="utf-8"?>
<contract xmlns="urn:oasis:names:tc:eContracts:1:0"
          xmlns:dc="http://purl.org/dc/elements/1.1/"
          xmlns:xi="http://www.w3.org/2001/XInclude">

  <title><text>Sample of sub and sup</text></title>

  <body>
    <block>
      <text>The Elkera<sup>3</sup> Business Narrative
Markup Language (BNML<sup>1</sup>)</text>
    </block>
    <block>
      <text>A<sub>10</sub></text>
    </block>
  </body>

</contract>

61. table

61.1. Synopsis

This is a table. This element and all other elements contained by table are taken from the OASIS Exchange Table Model. Please refer to that specification for full details of this element. [table1], [table2]

61.1.1. Content Model

table = element table {
    title?, tgroup+,

    table.attlist
}

table.attlist =
    common.attributes,
    orient.attribute,
    [a:defaultValue = "all"]
    attribute frame { "top" | "bottom" | "topbot" | "all" | "sides" | "none" }?,
    attribute colsep { xsd:boolean }?,
    attribute rowsep { xsd:boolean }?,
    attribute pgwide { xsd:boolean }?,
    table.attlist.extensions

table.attlist.extensions = empty

table ::=

Sequence of
- title
- One or more tgroup

61.1.2. Attributes

Common Attributes and orient.attribute

Additional Attributes

frame
- "top"
- "bottom"
- "topbot"
- "all"
- "sides"
- "none"
colsep
rowsep
pgwide
summary
title

61.2. Description

61.2.1. Attributes

Common Attributes and orient.attribute

Additional Attributes: This section only provides a brief description of each attribute's purpose. Please refer to the OASIS Exchange Table Model for details and processing semantics of these attributes.

frame

This is to control the table frame, that is the border rendered around the table:

Table B.12. (enumeration)

`top`	below title
`sides`	(left and right sides)
`bottom`	after information for last `row`
`topbot`	both `top` and `bottom`
`none`	none of the above
`all`	all of the above

colsep

This controls the display of the column separator to the right of the cells in the table.

rowsep

This controls the display of the row separator underneath the cell in the table.

pgwide

This controls whether the table spans the entire page.

summary

This is a summary of the table content. This attribute is provided to support the WAI Web Content Accessibility Guidelines.

title

This is the table title. This attribute should be used when the title element is not specified (i. e. when the table title is not required in the rendered text of the table). This attribute is provided to support the WAI Web Content Accessibility Guidelines.

61.2.2. Parents

These elements contain table: block

61.2.3. Children

The following elements occur inside table: tgroup and title

61.2.4. See also:

The TC noted the possibility of using markup for table for signatures. However, the TC thought that it would be more preferable to use markup specifically for signatures such as that provided by party-signature and signatory-group.

61.2.5. Example

Example B.34. Example showing a table

<?xml version="1.0" encoding="utf-8"?>
<contract xmlns="urn:oasis:names:tc:eContracts:1:0"
          xmlns:dc="http://purl.org/dc/elements/1.1/"
          xmlns:xi="http://www.w3.org/2001/XInclude">

  <title><text>Sample of
               - table
               - tgroup
  </text></title>

  <body>
    <block>
      <table>
        <tgroup cols="1">
          <colspec colnum="1" colname="C1" colwidth="10" colsep="true"
                rowsep="false" align="justify"/>
          <thead>
            <row><entry><block></block></entry></row>
          </thead>
          <tbody>
            <row><entry><block></block></entry></row>
          </tbody>
        </tgroup>
      </table>
    </block>
  </body>

</contract>

62. tbody

62.1. Synopsis

62.1.1. Content Model

tbody = element tbody {
    row+,

    tbody.attlist
}

tbody.attlist =
    common.attributes,
    [a:defaultValue = "middle"]
    attribute valign  { TableValign }?,
    tbody.attlist.extensions

TableValign = "top" | "middle" | "bottom"

tbody.attlist.extensions = empty

tbody ::=

One or more
- row

62.1.2. Attributes

Additional Attributes

valign

62.2. Description

This is the table body. This element and all other elements contained by table are taken from the OASIS Exchange Table Model. Please refer to that specification for full details of this element. [table1],[table2].

62.2.1. Attributes

This section only provides a brief description of each attribute's purpose. Please refer to the OASIS Exchange Table Model for details and processing semantics of these attributes: Common Attributes

valign

This is the default for all row and entry within the tbody element.

Table B.13. (enumeration)

`top`	Align content at the top of the row.
`middle`	Center content within the row (default)
`bottom`	Align content at the bottom of the row.

62.2.2. Parents

These elements contain tbody: tgroup

62.2.3. Children

The following elements occur inside tbody: row

62.2.4. Example:

Please see table.

63. term

63.1. Synopsis

63.1.1. Content Model

term has a mixed content model.

term = element term {
    inline.content,

    term.attlist
}

term.attlist =
        common.attributes,
        term.class.attribute,
        term.attlist.extensions

term.class.attribute =      standard.class
term.attlist.extensions =   empty

term ::=

Zero or more of

63.1.2. Attributes

Additional Attributes

"abbreviation"

63.2. Description

The term element contains a single term, either at its place of definition, or its place of reference.

63.2.1. Attributes

Additional Attributes:

abbreviation: This is to provide an abbreviation for a defined term. This attribute is provided to support the WAI Web Content Accessibility Guidelines.

63.2.2. Parents

These elements contain date: date-block party person-record terms text

63.2.3. Children

The following elements occur inside date:

conditional, em, field, reference, statutory-em, strike, sub, sup

63.2.4. See Also

phrase and field

63.2.5. Examples

Please see terms

64. terms

64.1. Synopsis

64.1.1. Content Model

terms has a mixed content model.

terms = element terms {
    (inline.content | term)*,

    terms.attlist
}


inline.content = (inline.content.inner)*
inline.content.inner = text | reference | em | statutory-em | strike | sub | sup | field

    inline.content.inner |= conditional
terms.attlist =
    common.attributes,
    terms.attlist.extensions


terms.attlist.extensions = empty

terms ::=

Zero or More of

64.1.2. Attributes

64.2. Description

This is for definitions where the meaning is related to more than a single term. The terms element may also contain text data (#PCDATA) between term elements to allow for punctuation.

64.2.1. Attributes

64.2.2. Parents

These element contain terms: definition

64.2.3. Children

The following elements occur inside terms:

conditional, em, field, reference, statutory-em, strike, sub, sup term

64.2.4. Examples

Example B.35. Examples of term and terms elements

<?xml version="1.0" encoding="utf-8"?>
<contract xmlns="urn:oasis:names:tc:eContracts:1:0"
          xmlns:dc="http://purl.org/dc/elements/1.1/"
          xmlns:xi="http://www.w3.org/2001/XInclude">

  <title><text>Sample of
               - terms and -term </text></title>

  <body>

    <block>
      <definition>
        <terms><term>You</term> or <term>Your</term></terms>
        <block>
          <text>means an individual or entity exercising rights under this Licence.</text>
        </block>
      </definition>
    </block>

  </body>

</contract>

65. text

text - contains text and elements that markup parts of text, particularly for formatting purposes.

65.1. Synopsis

65.1.1. Content Model

text has a mixed content model.


\text = element text {
    (text.content.inner)*,

    text.attlist
}

text.attlist =
    common.attributes,
    text.class.attribute,
    text.textflow.attribute,
    text.xmlspace.attribute,
    text.attlist.extensions

text.class.attribute =      standard.class
text.textflow.attribute =   attribute textflow  { "runon" }?

text.xmlspace.attribute =
        [ a:defaultValue = "default" ]
        attribute xml:space { "default" | "preserve" }?

text.attlist.extensions =   empty


inline.content = (inline.content.inner)*
inline.content.inner = text | reference | em | statutory-em | strike | sub | sup | field

    inline.content.inner |= conditional

text.content = (text.content.inner)*
text.content.inner = inline.content.inner | object | term | phrase | field
                     | note | note-in-line | name | address | date | party | person-record

text ::=

Choice of:

65.1.2. Attributes

Additional attributes:

textflow (enumeration)
- "runon"
xml:space (enumeration)
- "default"
- "preserve"

65.2. Description

This is a container element for text data (#PCDATA) and other inline elements such as those for emphasis. It is a semantic line element that enables formatting control #PCDATA that occurs between and after block-formatted content.

65.2.1. Attributes

Additional Attributes:

textflow This indicates whether this text element should be rendered in the same line as the previous element. Normally, if a text element occurs after a structure that is formatted as a block, there will be a line break. If this attribute is runon, then it will be on the same line.
Table B.14. (enumeration)
"runon"
If this text follows a structure that is formatted as a block, the enclosed characters will appear on the same line as the text from the information from block.
xml:space This attribute is used to preserve white-space within an element. This attribute is defined by the XML specification. Please refer to that specification for processing semantics.
Table B.15. (enumeration)
"default"
Use application default
"preserve"
Preserve white space

65.2.2. Parents

These elements contain text: address, block, citation Conditional date date-block, em, fallback name note-in-line party, person-record, reference sub, signature-line, statutory-em sup, subtitle, strike, term terms, and title

65.2.3. Children

The following elements occur inside text: address, date, em, field, note, note-in-line, object, party, person-record, phrase, reference, statutory-em, strike, sub, sup, and term

65.2.4. See Also

term, note-in-line

65.2.5. Examples

The two examples below show the text in its most typical home, a block element as well as some of the inline.content such as em and sub that text often contains:

Example B.36. An example showing text element

<?xml version="1.0" encoding="utf-8"?>
<contract xmlns="urn:oasis:names:tc:eContracts:1:0"
          xmlns:dc="http://purl.org/dc/elements/1.1/"
          xmlns:xi="http://www.w3.org/2001/XInclude">

  <title><text>Sample of sub and sup</text></title>

  <body>
    <block>
      <text>The Elkera<sup>3</sup> Business Narrative
Markup Language (BNML<sup>1</sup>)</text>
    </block>
    <block>
      <text>A<sub>10</sub></text>
    </block>
  </body>

</contract>

Example B.37. Another example showing text element including inline elements

<contract xmlns="urn:oasis:names:tc:eContracts:1:0"
          xmlns:dc="http://purl.org/dc/elements/1.1/"
          xmlns:xi="http://www.w3.org/2001/XInclude">

  <title><text>Sample of inline elements</text></title>

  <body>
    <block>
      <text>The location to deliver <em>the item</em>
    <strike>has to be one of <statutory-em>designated
    terminals.</statutory-em></strike> will be any places.</text>
    </block>
  </body>

</contract>

66. tgroup

66.1. Synopsis

This is a set of rows and possibly a header from a table.

66.1.1. Content Model

tgroup = element tgroup {
    colspec*, thead?, tbody,

    tgroup.attlist
}

tgroup.attlist =
    common.attributes,
    attribute cols     { xsd:NMTOKEN },
    [a:defaultValue = "1"]
    attribute colsep   { xsd:boolean }?,
    [a:defaultValue = "1"]
    attribute rowsep   { xsd:boolean }?,
    [a:defaultValue = "left"]
    attribute align    { TableAlign }?,
    tgroup.attlist.extensions


TableAlign = "left" | "right" | "center" | "justify"
tgroup.attlist.extensions = empty

tgroup ::=

Sequence of
- Zero or more colspec
- Zero or one thead
- Exactly one tbody

66.1.2. Attributes

Additional Attributes:

cols
colsep
rowsep
align

66.2. Description

This is the table group. This element and all other elements contained by table are taken from the OASIS Exchange Table Model. Please refer to that specification for full details of this element. [table1],[table2].

66.2.1. Attributes

This section only provides a brief description of each attribute's purpose. Please refer to the OASIS Exchange Table Model for details and processing semantics of these attributes.

Additional Attributes:

align

The horizontal alignment for content contained in the cell.

Table B.16. (enumeration)

`left`	align to the left (default)
`right`	align to the right (default)
`center`	center the text
`justify`	justify the text

cols

Number of columns in the tgroup

colsep

This controls the display of the column separator to the right of the cells within the tgroup.

rowsep

This controls the display of this row separator underneath the cells in this tgroup.

66.2.2. Parents

These elements occur inside tgroup: table

66.2.3. Children

The following elements occur inside tgroup: colspec, thead and tbody

66.2.4. Example:

Please see table.

67. thead

67.1. Synopsis

This is the table header.

67.1.1. Content Model

thead = element thead {
    row+,

    thead.attlist
}

thead.attlist =
    common.attributes,
    [a:defaultValue = "middle"]
    attribute valign  { TableValign }?,
    thead.attlist.extensions

TableValign = "top" | "middle" | "bottom"

thead.attlist.extensions = empty

thead ::=

One or more
- row

67.1.2. Attributes

Additional Attributes

valign

67.2. Description

This is the table header. This element and all other elements contained by table are taken from the OASIS Exchange Table Model. Please refer to that specification for full details of this element. [table1],[table2].

67.2.1. Attributes

This element only provides brief description of each attribute's purpose. Please refer to the OASIS Exchange Table Model for details and processing semantics of these attributes.

valign

The vertical alignment for all row and entry within the thead element.

Table B.17. (enumeration)

`top`	Align content at the top of cell.
`middle`	Centered content within the cell.
`bottom`	Align content at the bottom of the cell.

67.2.2. Parents

These elements contain thead: tgroup

67.2.3. Children

The following elements occur inside thead: row

67.2.4. Example:

Please see table.

68. title

68.1. Synopsis

68.1.1. Content Model

title = element title {
    \text+,

    title.attlist
}

title.attlist =
    common.attributes,
    title.attlist.extensions

title.attlist.extensions = empty

title ::=

Zero or more occurrences of
- text

68.1.2. Attributes

68.2. Description

This is used to indicate the title for the contract itself, attachments, elements in lists, and many other elements, as listed below.

68.2.1. Parents

These elements contain title: attachment background back body contract inclusion item block.item parties table

68.2.2. Children

The following elements occur inside title: text

68.2.3. See Also:

subtitle

68.2.4. Examples

Example B.38. To illustrate a title in an otherwise minimal contract.

<?xml version="1.0" encoding="utf-8"?>
<contract xmlns="urn:oasis:names:tc:eContracts:1:0"
          xmlns:dc="http://purl.org/dc/elements/1.1/"
          xmlns:xi="http://www.w3.org/2001/XInclude">
 <title><text>Minimum XML sample</text></title>
 <body>
 </body>
</contract>

69. witness

69.1. Synopsis

witness (a person who witnesses the signing of a contract or document)

69.1.1. Content Model

witness = element witness {

    (signature-line | block)*,

    witness.attlist
}

witness.attlist =
    common.attributes,
    witness.attlist.extensions

witness.attlist.extensions = empty

witness ::=

Zero or more of
- signature-line
- block

69.1.2. Attributes

69.2. Description

This is the person who witnesses the signing of the document.

69.2.1. Attributes