ontouml-schema.json

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "$id": "https://w3id.org/ontouml/schema/v1.0.0-draft",
  "title": "OntoUML Schema",
  "description": "The OntoUML Schema defines the JSON serializations of OntoUML ontologies and their contents according to the OntoUML Metamodel project.",
  "oneOf": [{ "$ref": "#/definitions/OntoumlElement" }],
  "definitions": {
    "OntoumlElement": {
      "$id": "#OntoumlElement",
      "title": "OntoUML Element",
      "description": "An identified element of an OntoUML ontology according to the OntoUML Metamodel, which includes projects, model elements, diagrams, views, and shapes.",
      "allOf": [
        {
          "type": "object",
          "properties": {
            "id": {
              "title": "id",
              "description": "Determines the unique identifier for an OntoUML element in an ontology using a non-empty string.",
              "$ref": "#/definitions/id"
            },
            "created": {
              "title": "created",
              "description": "Determines when the element was created using a string in one of the following formats: year, year-month, date, or date-time.",
              "$ref": "#/definitions/pointInTime"
            },
            "modified": {
              "title": "modified",
              "description": "Determines when the element was modified using a string in one of the following formats: year, year-month, date, or date-time.",
              "oneOf": [
                { "type": "null" },
                { "$ref": "#/definitions/pointInTime" }
              ]
            }
          },
          "required": ["id", "created", "modified"]
        },
        {
          "oneOf": [
            { "$ref": "#/definitions/NamedElement" },
            { "$ref": "#/definitions/Shape" },
            { "$ref": "#/definitions/View" }
          ]
        }
      ]
    },
    "NamedElement": {
      "$id": "#NamedElement",
      "title": "Named Element",
      "description": "An OntoUML element that can be assigned a name and other descriptive information.",
      "allOf": [
        {
          "type": "object",
          "properties": {
            "name": {
              "title": "name",
              "description": "Determines the name of the named element using language string.",
              "oneOf": [
                { "type": "null" },
                { "$ref": "#/definitions/languageString" }
              ]
            },
            "alternativeNames": {
              "title": "alternative names",
              "description": "Determines alternative names of the named element using an array of language strings. Alternative names are not translations of the named element, but indeed alternatives or synonyms to the main one.",
              "type": "array",
              "items": { "$ref": "#/definitions/languageString" }
            },
            "description": {
              "title": "description",
              "description": "Determines a free-text account of the named element using language string.",
              "oneOf": [
                { "type": "null" },
                { "$ref": "#/definitions/languageString" }
              ]
            },
            "editorialNotes": {
              "title": "editorial notes",
              "description": "Determines general notes about the named element using an array of language strings. Editorial notes are typically notes on the development process and must not be confused with descriptions.",
              "type": "array",
              "items": { "$ref": "#/definitions/languageString" }
            },
            "creators": {
              "title": "creators",
              "description": "Identifies the agents who contributed to the creation of the named element.",
              "type": "array",
              "items": { "$ref": "#/definitions/resource" }
            },
            "contributors": {
              "title": "contributors",
              "description": "Identifies the agents who contributed to the development of the named element.",
              "type": "array",
              "items": { "$ref": "#/definitions/resource" }
            }
          },
          "required": [
            "name",
            "alternativeNames",
            "description",
            "editorialNotes",
            "creators",
            "contributors"
          ]
        },
        {
          "oneOf": [
            { "$ref": "#/definitions/Project" },
            { "$ref": "#/definitions/ModelElement" }
          ]
        }
      ]
    },
    "Project": {
      "$id": "#Project",
      "title": "Project",
      "description": "A named element that serves as the container of an entire OntoUML ontology, including the elements of both the abstract syntax (i.e., model elements) and the concrete syntax (i.e., diagrams, view, and shapes).",
      "type": "object",
      "properties": {
        "type": {
          "title": "type",
          "description": "Determines an object of type 'Project.'",
          "const": "Project"
        },
        "elements": {
          "title": "elements",
          "description": "Contains the OntoUML elements that are part of the project.",
          "type": "array",
          "items": {
            "oneOf": [
              { "$ref": "#/definitions/Diagram" },
              { "$ref": "#/definitions/View" },
              { "$ref": "#/definitions/PackageableElement" }
            ]
          }
        },
        "root": {
          "title": "root",
          "description": "Identifies the root package of a project (the package containing all other model elements of the project) if present.",
          "oneOf": [{ "type": "null" }, { "$ref": "#/definitions/id" }]
        },
        "publisher": {
          "title": "publisher",
          "description": "Identifies the agent responsible for making the project available. The publisher does not need to have created or contributed to the resource.",
          "oneOf": [{ "type": "null" }, { "$ref": "#/definitions/resource" }]
        },
        "designedForTasks": {
          "title": "designed for tasks",
          "description": "Identifies goals that motivated the development of the project. The OntoUML/UFO Catalog Metadata Vocabulary (OCMV) provides a set of goals that be reused as recurrent modeling goals:\n\n- ocmv:ConceptualClarification: The project was created as the result of an ontological analysis of a concept, language, or domain of interest that sought to conceptually clarify and untangle complex notions and relations.\n\n- ocmv:DataPublication: The project was created to support the publication of some datasets. For instance, in the case of a conceptual model used to generate an OWL vocabulary to publish tabular data as linked open data on the web.\n\n- ocmv:DecisionSupportSystem: The project was created during the development of a decision support system.\n\n- ocmv:Example: The project was created to demonstrate how OntoUML can be used to solve a certain modeling challenge, to support an experiment involving OntoUML, or to exemplify how a generic model can be reused in more concrete scenarios.\n\n- ocmv:InformationRetrieval: The project was created to support the design of an information retrieval system.\n\n- ocmv:Interoperability: The project was created to support data integration, vocabulary alignment, or the interoperability of software systems.\n\n- ocmv:LanguageEngineering: The project was created for the design of a domain-specific modeling language.\n\n- ocmv:Learning: The project was created so that its authors could learn UFO and OntoUML. This usually applies to models developed by students as part of their course assignments.\n\n- ocmv:SoftwareEngineering: The project was created during the development of an information system. For instance, in the case of a conceptual model used to generate a relational database.",
          "type": "array",
          "items": { "$ref": "#/definitions/resource" }
        },
        "license": {
          "title": "license",
          "description": "Identifies a legal document under which the project is made available, e.g., \"CC BY 4.0\" <https://creativecommons.org/licenses/by/4.0/>.",
          "oneOf": [{ "type": "null" }, { "$ref": "#/definitions/resource" }]
        },
        "accessRights": {
          "title": "access rights",
          "description": "Identifies a document or a text concerning who and how the project can be accessed. E.g., the document <http://publications.europa.eu/resource/authority/access-right/PUBLIC> informs that something is \"publicly accessible by everyone.\"",
          "type": "array",
          "items": { "$ref": "#/definitions/resource" }
        },
        "themes": {
          "title": "themes",
          "description": "Identifies the central themes of the project according to a theme taxonomy. In the OntoUML/UFO Catalog Metadata Vocabulary (OCMV), for example, the theme of a project must be a concept from the Library of Congress Classification (LCC), such as, \"Class S - Agriculture\" or \"Class T - Technology.\"\"",
          "type": "array",
          "items": { "$ref": "#/definitions/resource" }
        },
        "contexts": {
          "title": "contexts",
          "description": "Identifies the contexts in which the project was developed. The OntoUML/UFO Catalog Metadata Vocabulary (OCMV) provides a set of recurrent modeling contexts:\n\n- ocmv:Research: The project was developed as part of a research project. This usually implies that the project was featured in a scientific publication.\n\n- ocmv:Industry: The project was developed for a public or private organization.\n\n- ocmv:Classroom: The project was developed within the context of a course on conceptual modeling, most likely as a course assignment.",
          "type": "array",
          "items": { "$ref": "#/definitions/resource" }
        },
        "ontologyTypes": {
          "title": "ontology types",
          "description": "Identifies the classifications of the project according to its scope. The OntoUML/UFO Catalog Metadata Vocabulary (OCMV) provides a set of recurrent modeling scopes based on the work of Roussey et al. (2011):\n\n- ocmv:Core: An ontology that grasps the central concepts and relations of a given domain, possibly integrating several domain ontologies and being applicable in multiple scenarios. E.g., UFO-S, a commitment-based ontology of services, can be considered a core ontology because it applies to services in multiple domains, such as medical, financial, and legal services.\n\n- ocmv:Domain: An ontology that describes how a community conceptualizes a phenomenon of interest. In general, a domain ontology formally characterizes a much narrower domain than a core ontology does. E.g., OntoBio is a domain ontology of biodiversity.\n\n- ocmv:Application: An ontology that specializes a domain ontology where there could be no consensus or knowledge sharing. It represents the particular model of a domain according to a single viewpoint of a user or a developer.",
          "type": "array",
          "items": { "$ref": "#/definitions/resource" }
        },
        "representationStyle": {
          "title": "representation style",
          "description": "Identifies the representation style adopted in the project between \"OntoUML Style\" and \"UFO Style\":\n\n- ocmv:OntoumlStyle: Characterizes a project that contains at least one class, relation, or property using a valid OntoUML stereotype.\n\n- ocmv:UfoStyle: Characterizes a project that contains at least one class or relation from UFO without an OntoUML stereotype.",
          "oneOf": [{ "type": "null" }, { "$ref": "#/definitions/resource" }]
        },
        "namespace": {
          "title": "namespace",
          "description": "Determines the namespace for all OntoUML elements in the project using a string in URI format. When present, the namespace appended with the id of any element in the project should form a globally unique resolvable URI for identification in the web as a FAIR Digital Object.",
          "oneOf": [{ "type": "null" }, { "type": "string", "format": "uri" }]
        },
        "landingPages": {
          "title": "landing pages",
          "description": "Identifies the web pages where one can access the project. E.g., <https://www.model-a-platform.com> is the landing page of the Digital Platform Ontology.",
          "type": "array",
          "items": { "type": "string", "format": "uri" }
        },
        "sources": {
          "title": "source",
          "description": "Identifies resources that contain, present, or significantly influenced the development of the project. We recommend the use of persistent and resolvable identifiers to refer to these resources, such as the Digital Object Identifier (DOI) or DBLP''s URI, such as, <https://doi.org/10.3233/AO-150150>, or <https://dblp.org/rec/journals/ao/Morales-Ramirez15>.",
          "type": "array",
          "items": { "type": "string", "format": "uri" }
        },
        "bibliographicCitations": {
          "title": "bibliographic citation",
          "description": "Determines bibliographic references for the project using language strings. E.g., \"Weigand, H., Johannesson, P., & Andersson, B. (2021). An artifact ontology for design science research. Data & Knowledge Engineering, 133\".",
          "type": "array",
          "items": { "$ref": "#/definitions/languageString" }
        },
        "keywords": {
          "title": "keywords",
          "description": "Determines the domains (partially) described by the project using language strings. E.g., the User Feedback Ontology is described with the keywords \"online user feedback\", \"software engineering\", and \"requirements engineering\".",
          "type": "array",
          "items": { "$ref": "#/definitions/languageString" }
        },
        "acronyms": {
          "title": "acronyms",
          "description": "Determines the acronyms one can use to refer to the project using strings. E.g., \"RDBS-O\", \"COVER\", \"ROT\".",
          "type": "array",
          "items": { "type": "string", "minLength": 1 }
        },
        "languages": {
          "title": "languages",
          "description": "Determines the languages in which the lexical labels of the project are written using strings. This field should use values listed in the IANA Language Sub Tag Registry, such as, \"en\" and \"pt\".",
          "type": "array",
          "items": { "type": "string", "minLength": 1 }
        }
      },
      "required": [
        "type",
        "elements",
        "root",
        "publisher",
        "designedForTasks",
        "license",
        "accessRights",
        "themes",
        "contexts",
        "ontologyTypes",
        "representationStyle",
        "namespace",
        "landingPages",
        "sources",
        "bibliographicCitations",
        "keywords",
        "acronyms",
        "languages"
      ]
    },
    "ModelElement": {
      "$id": "#ModelElement",
      "title": "Model Element",
      "description": "A named element that represents an element of the language's abstract syntax (e.g., a class, a relation, or a generalization).",
      "allOf": [
        {
          "type": "object",
          "properties": {
            "customProperties": {
              "title": "custom properties",
              "description": "Determines custom properties of the model element using key-value pairs. In UML, for instance, this custom properties are represented through tagged values.",
              "oneOf": [{ "type": "null" }, { "type": "object" }]
            }
          },
          "required": ["customProperties"]
        },
        {
          "oneOf": [
            { "$ref": "#/definitions/Generalization" },
            { "$ref": "#/definitions/GeneralizationSet" },
            { "$ref": "#/definitions/Link" },
            { "$ref": "#/definitions/Literal" },
            { "$ref": "#/definitions/Note" },
            { "$ref": "#/definitions/Package" },
            { "$ref": "#/definitions/Decoratable" }
          ]
        }
      ]
    },
    "Generalization": {
      "$id": "#Generalization",
      "title": "Generalization",
      "description": "A model element that represents the generalization of a specific classifier into a general classifier. When read in the inverse direction, a generalization is referred to as a specialization.\n\nExamples include the generalization of a specific class \"Student\" into a general class \"Person,\" and the generalization of a specific relation \"close friends with\" into a general relation \"friends with\".\n\nA generalization can only connect two classifiers of the same type, i.e., it can either connect two class elements or two relation elements.",
      "type": "object",
      "properties": {
        "type": {
          "title": "type",
          "description": "Determines the type of a generalization object.",
          "const": "Generalization"
        },
        "general": {
          "title": "general",
          "description": "Identifies the general classifier in a generalization element. E.g., in the generalization of \"Student\" into \"Person\", \"Person\" is the general classifier.",
          "$ref": "#/definitions/id"
        },
        "specific": {
          "title": "specific",
          "description": "Identifies the general classifier in a generalization element. E.g., in the generalization of \"Student\" into \"Person\", \"Student\" is the specific classifier.",
          "$ref": "#/definitions/id"
        }
      },
      "required": ["type", "general", "specific"]
    },
    "GeneralizationSet": {
      "$id": "#GeneralizationSet",
      "title": "Generalization Set",
      "description": "A model element that represents a group of connected generalization elements. A generalization set can define disjoint and/or complete constraints over the generalizations it groups.\n\nExamples include the incomplete (i.e., non-complete) and overlapping (i.e., non-disjoint) generalization set of \"Person\" into \"Student\" and \"Teacher\", and the disjoint and complete generalization set of \"Person\" into \"Child\" and \"Adult\".\n\nAll generalizations in the generalization set must share a common general classifier.",
      "type": "object",
      "properties": {
        "type": {
          "title": "type",
          "description": "Determines the type of a generalization set object.",
          "const": "GeneralizationSet"
        },
        "isDisjoint": {
          "title": "is disjoint",
          "description": "Determines whether the specific classifiers in the generalization set have disjoint extensions.\n\nExamples include the generalization set involving \"Child\" and \"Adult\" generalized into \"Person\", where the \"is disjoint\" as \"true\" indicates that no person is simultaneously an instance of \"Child\" and \"Adult.\"",
          "oneOf": [{ "type": "null" }, { "type": "boolean" }]
        },
        "isComplete": {
          "title": "is complete",
          "description": "Determines whether the specific classifiers in the generalization set completely cover the extension of the general classifier.\n\nExamples include the generalization set involving \"Child\" and \"Adult\" generalized into \"Person\", where the \"is complete\" as \"true\" indicates that every person is either an instance of \"Child\" or \"Adult.\"",
          "oneOf": [{ "type": "null" }, { "type": "boolean" }]
        },
        "generalizations": {
          "title": "generalizations",
          "description": "Identifies all generalizations that are involved by the generalization set.",
          "type": "array",
          "items": { "$ref": "#/definitions/id" }
        },
        "categorizer": {
          "title": "categorizer",
          "description": "Identifies the high-order class that classifies (i.e., is instantiated by) every specific class in the generalization set.\n\nFor example, \"Academic Role\" as the categorizer of the generalization set of \"Person\" into \"Student\" and \"Teacher\" representing the specific classes as instances of the categorizer.\n\nA categorizer can only be present in generalization sets involving exclusively classes.",
          "oneOf": [{ "type": "null" }, { "$ref": "#/definitions/id" }]
        }
      },
      "required": [
        "type",
        "isDisjoint",
        "isComplete",
        "generalizations",
        "categorizer"
      ]
    },
    "Link": {
      "$id": "#Link",
      "title": "Link",
      "description": "A model element that connects a note to a model element it concerns.",
      "type": "object",
      "properties": {
        "type": {
          "title": "type",
          "description": "Determines the type of a link object.",
          "const": "Link"
        },
        "note": {
          "title": "note",
          "description": "Identifies the note the link connects.",
          "$ref": "#/definitions/id"
        },
        "element": {
          "title": "element",
          "description": "Identifies the model element the link connects.",
          "$ref": "#/definitions/id"
        }
      },
      "required": ["type", "note", "element"]
    },
    "Literal": {
      "$id": "#Literal",
      "title": "Literal",
      "description": "A model element that represents a specific value within an enumerated set of values. Examples include each letter in an A to F letter grading scale, listed in a class \"Letter Grade\" decorated with the stereotype \"enumeration\".",
      "type": "object",
      "properties": {
        "type": {
          "title": "type",
          "description": "Determines the type of a literal object.",
          "const": "Literal"
        }
      },
      "required": ["type"]
    },
    "Note": {
      "$id": "#Note",
      "title": "Note",
      "description": "A model element that contains an annotation about the ontology or some of its elements. A note can also be used to represent a constraint in both natural or structured language (i.e., first-order logic, or OCL).",
      "type": "object",
      "properties": {
        "type": {
          "title": "type",
          "description": "Determines the type of a note object.",
          "const": "Note"
        },
        "text": {
          "title": "text",
          "description": "Determines the contents of a note using a language string.",
          "$ref": "#/definitions/languageString"
        }
      },
      "required": ["type", "text"]
    },
    "Package": {
      "$id": "#Package",
      "title": "Package",
      "description": "A model element that can group other model elements that are referred to as \"packageable elements.\" Package elements are used to perform the modularization of an ontology.\n\nWhile the OntoUML Metamodel does not require package elements to follow a tree structure (i.e., it allows overlapping packages), ontologies that require UML representations should adhere to this constraint for compatibility.",
      "type": "object",
      "properties": {
        "type": {
          "title": "type",
          "description": "Determines the type of a package object.",
          "const": "Package"
        },
        "contents": {
          "title": "contents",
          "description": "Identifies the contents of a package element.",
          "type": "array",
          "items": { "$ref": "#/definitions/id" }
        }
      },
      "required": ["type", "contents"]
    },
    "Decoratable": {
      "$id": "#Decoratable",
      "title": "Decoratable",
      "description": "A model element that can be decorated with a stereotype to identify its ontological properties according to the Unified Foundational Ontology (UFO).\n\nExamples include a class decorated with the stereotype \"kind\" identifying it as a type of object that provides an identity principle to its instances.",
      "allOf": [
        {
          "type": "object",
          "properties": {
            "stereotype": {
              "title": "stereotype",
              "description": "Determines the type of a model element according to Unified Foundational Ontology (UFO).",
              "oneOf": [
                { "type": "null" },
                { "type": "string", "minLength": 1 }
              ]
            },
            "isDerived": {
              "title": "is derived",
              "description": "Determines whether the model element is derived from a different one, i.e., whether a different element serves as its truthmaker.\n\nExamples include the comparative relation \"is heavier than\" between two physical objects which is derived from their \"Weight\" quality.",
              "oneOf": [{ "type": "null" }, { "type": "boolean" }]
            }
          },
          "required": ["stereotype", "isDerived"]
        },
        {
          "oneOf": [
            { "$ref": "#/definitions/Property" },
            { "$ref": "#/definitions/Classifier" }
          ]
        }
      ]
    },
    "Property": {
      "$id": "#Property",
      "title": "Property",
      "description": "A decoratable element that represents an attribute of a class, or one end of a relation.\n\nExamples include the attribute \"name\" of the class \"Person\", and the ends of the binary relation \"studies in\" connected to the classes \"Student\" and \"University.\"\n\nInstances of class and relation elements bear values for the properties these classifiers contain, according to the constraints specified within each property. For example, the value assigned to a property in an instance must be itself an instance of the classifier in property type.",
      "type": "object",
      "properties": {
        "type": {
          "title": "type",
          "description": "Determines the type of a property object.",
          "const": "Property"
        },
        "subsettedProperties": {
          "title": "subsetted properties",
          "description": "Identifies the properties (relation ends) that provide subsetting constraints to the property.\n\nExamples include, in the relations (i) \"works for\" from \"Employee\" to \"Organization\", and (ii) \"teaches for\" from \"Teacher\" to \"University\", both relation ends of (ii) are subsets of their respect ends in (i).\n\nSubsetting can only occur on the relation ends when both sides of the involved relations are connected to the same classifiers or classifiers that are in the same generalization chain.\n\nSubsetting can also be represented through a generalization between relations.",
          "type": "array",
          "items": { "$ref": "#/definitions/id" }
        },
        "redefinedProperties": {
          "title": "redefined properties",
          "description": "Identifies the properties (relation ends) that provide redefinition constraints to the property.\n\nExamples include, in the relations (i) \"works in\" from \"Project Member\" to \"Project\", and (ii) \"leads\" from \"Project Leader\" to \"Project\", where the member end is redefined for the leader who can only be connected to the project through that specific relation.\n\nRedefinition can only occur on the relation ends when both sides of the involved relations are connected to the same classifiers or classifiers that are in the same generalization chain.",
          "type": "array",
          "items": { "$ref": "#/definitions/id" }
        },
        "aggregationKind": {
          "title": "aggregation kind",
          "description": "Determines whether the property (a relation end) is a whole in a parthood (mereological) relation using an enumerated string.\n\nExamples include \"Project Member\" as a \"shared\" part of a \"Project Team\" and an \"Engine\" as a \"composite\" part of a \"Vehicle.\"\n\nThe possible values for aggregation kind are \"composite\" (when parts are exclusive to one whole), \"shared\" (when parts can be shared), and \"none\" for non-parthood relations. The \"null\" is also interpreted as \"none.\"",
          "oneOf": [
            { "type": "null" },
            { "enum": ["COMPOSITE", "SHARED", "NONE"] }
          ]
        },
        "cardinality": {
          "title": "cardinality",
          "description": "Determines the cardinality of a property using a string.\n\nExamples include \"Person\" with cardinality \"1\" (exactly one) in the property (attribute) \"name\", and cardinality \"0..*\" (zero or more) in the property (related end) \"friends\" of the relation \"friends with\".\n\nThe cardinality should follow the regular expression \"^\\d+(\\.\\.(\\d+|\\*))?$\", where the number before \"..\" represents the lower bound, and the number or \"*\" after represents the upper bound. In case the \"..\" is not present, a number represents an exact number of instances, and \"*\" represents \"zero or more\" instances.\n\nThis regular expression is not enforced to accommodate theoretical ranges as expression, such as, \"a..b\".",
          "oneOf": [{ "type": "null" }, { "type": "string", "minLength": 1 }]
        },
        "isOrdered": {
          "title": "is ordered",
          "description": "Determines whether the order of assignments of a property carries meaning using a boolean. This boolean only regards properties whose maximum cardinality is greater than one.",
          "oneOf": [{ "type": "null" }, { "type": "boolean" }]
        },
        "isReadOnly": {
          "title": "is read-only",
          "description": "Determines whether the assignments of a property are immutable using a boolean.",
          "oneOf": [{ "type": "null" }, { "type": "boolean" }]
        },
        "propertyType": {
          "title": "property type",
          "description": "Identifies the classifier instantiated by the values assigned to the property.",
          "oneOf": [{ "type": "null" }, { "$ref": "#/definitions/id" }]
        }
      },
      "required": [
        "type",
        "subsettedProperties",
        "redefinedProperties",
        "aggregationKind",
        "cardinality",
        "isOrdered",
        "isReadOnly",
        "propertyType"
      ]
    },
    "Classifier": {
      "$id": "#Classifier",
      "title": "Classifier",
      "description": "A decoratable element (either a class or a relation) that defines properties exhibited by its instances.",
      "allOf": [
        {
          "type": "object",
          "properties": {
            "isAbstract": {
              "title": "is abstract",
              "description": "Determines whether the classifier can have direct instances using a boolean. Abstract classifiers can only have instances when these are instances of some other classifier that is not abstract (i.e., concrete) and is a specialization of the abstract one.",
              "oneOf": [{ "type": "null" }, { "type": "boolean" }]
            },
            "properties": {
              "title": "properties",
              "description": "Identifies the properties contained in a classifier. These properties are referred to as attributes when contained by classes, and relation ends when contained by relations. In the case of relations, the properties array must be ordered.",
              "type": "array",
              "items": { "$ref": "#/definitions/id" }
            }
          },
          "required": ["isAbstract", "properties"]
        },
        {
          "oneOf": [
            { "$ref": "#/definitions/Class" },
            { "$ref": "#/definitions/Relation" }
          ]
        }
      ]
    },
    "Class": {
      "$id": "#Class",
      "title": "Class",
      "description": "A classifier that defines the properties of a set of \"individualized\" entities (i.e., non-relational) of the subject domain.\n\nExamples include \"Person\", \"Enrollment\", and \"Grade\".\n\nThe instances of a class may include entities such as objects (e.g., people, organizations, vehicles), reified properties (e.g., leafs' colors, agents' intentions, enrollments), and bare values (e.g., a number or a literal).",
      "type": "object",
      "properties": {
        "type": {
          "title": "type",
          "description": "Determines the type of a class object.",
          "const": "Class"
        },
        "literals": {
          "title": "literals",
          "description": "Identifies the literals of an enumeration class.",
          "type": "array",
          "items": { "$ref": "#/definitions/id" }
        },
        "restrictedTo": {
          "title": "restrictedTo",
          "description": "Determines the possible ontological natures of the instances of a class using an array of enumerated strings.\n\nExamples include the class \"Vehicle\" restricted to having \"functional-complex\" instances and the class \"Insured Item\" restricted to \"functional-complex\" and \"relator\" (e.g., employment insurance).",
          "type": "array",
          "items": {
            "enum": [
              "abstract",
              "collective",
              "event",
              "extrinsic-mode",
              "functional-complex",
              "intrinsic-mode",
              "quality",
              "quantity",
              "relator",
              "situation",
              "type"
            ]
          }
        },
        "isPowertype": {
          "title": "isPowertype",
          "description": "Determines whether the high-order class is a \"Cardelli powertype\" using a boolean. In other words, determines whether the high-order class is defined as the one whose instances are its base type plus all possible specializations of it.",
          "oneOf": [{ "type": "null" }, { "type": "boolean" }]
        },
        "order": {
          "title": "order",
          "description": "Determines the instantiation order of a class using a string. Examples include ordered classes such as first-order classes (order \"1\"), second-order classes (order \"2\"), and third-order classes (order \"3\"), as well as orderless classes (order \"*\").",
          "oneOf": [
            { "type": "null" },
            { "type": "string", "pattern": "^(\\d+|\\*)$" }
          ]
        }
      },
      "required": ["type", "literals", "restrictedTo", "isPowertype", "order"]
    },
    "Relation": {
      "$id": "#Relation",
      "title": "Relation",
      "description": "A classifier that defines the properties of a set of relations of the subject domain.\n\nExamples include \"studies in\", \"buys product from\" (ternary relation), and derivation relations (e.g., between material relations and relators).",
      "oneOf": [
        { "$ref": "#/definitions/BinaryRelation" },
        { "$ref": "#/definitions/NaryRelation" }
      ]
    },
    "BinaryRelation": {
      "$id": "#BinaryRelation",
      "title": "Binary Relation",
      "description": "A relation that defines the properties of a set of binary relations of the subject domain.\n\nExamples include \"studies in\", and derivation relations (e.g., between material relations and relators).\n\nA binary relation may either connect two classes, or a relation (as source) and a class (as target) in the case of derivation relations connecting descriptive relations to the classes that serve as their truthmakers (as in the relation between the material relation \"studies in\" and the \"Enrollment\" relator).",
      "type": "object",
      "properties": {
        "type": {
          "title": "type",
          "description": "Determines the type of a binary relation object.",
          "const": "BinaryRelation"
        }
      },
      "required": ["type"]
    },
    "NaryRelation": {
      "$id": "#NaryRelation",
      "title": "N-ary Relation",
      "description": "A relation that defines the properties of a set of relations of the subject domain that connect more than two members.\n\nExamples include \"studies in\", \"buys product from\" (ternary relation), and derivation relations (e.g., between material relations and relators).",
      "type": "object",
      "properties": {
        "type": {
          "title": "type",
          "description": "Determines the type of a n-ary relation object.",
          "const": "NaryRelation"
        }
      },
      "required": ["type"]
    },
    "Diagram": {
      "$id": "#Diagram",
      "title": "Diagram",
      "description": "A named element that contains the visual representation (i.e., the concrete syntax) of an OntoUML model or of a portion of it.",
      "type": "object",
      "properties": {
        "type": {
          "title": "type",
          "description": "Determines the type of a diagram object.",
          "const": "Diagram"
        },
        "owner": {
          "title": "owner",
          "description": "Identifies the model element that is the owner of a diagram.",
          "oneOf": [{ "type": "null" }, { "$ref": "#/definitions/id" }]
        },
        "views": {
          "title": "views",
          "description": "Identifies the views contained in the diagram.",
          "type": "array",
          "items": { "$ref": "#/definitions/id" }
        }
      },
      "required": ["type", "owner", "views"]
    },
    "View": {
      "$id": "#View",
      "title": "View",
      "description": "An OntoUML element that represents a single model element in a diagram.\n\nA view element connects a model element to the shapes in a diagram necessary to represent a single occurrence of it. For example, an n-ary relation view connects a single relation element to one diamond and a set of paths that represent a single occurrence of it in a diagram. Multiple views can represent multiple occurrences of an element in the same diagram.\n\nA view element is responsible for what portions of a model element are present in a single diagram representation (e.g., whether the cardinality of a property is shown), unlike a shape, which is responsible for aspects of the actual drawing (e.g., how to render a portion of a view, in which position, and with which dimensions).",
      "allOf": [
        {
          "type": "object",
          "properties": {
            "isViewOf": {
              "title": "is view of",
              "description": "Identifies the model element that the view represents in the diagram.",
              "$ref": "#/definitions/id"
            }
          },
          "required": ["isViewOf"]
        },
        {
          "oneOf": [
            { "$ref": "#/definitions/ClassView" },
            { "$ref": "#/definitions/GeneralizationSetView" },
            { "$ref": "#/definitions/NaryRelationView" },
            { "$ref": "#/definitions/NoteView" },
            { "$ref": "#/definitions/PackageView" },
            { "$ref": "#/definitions/BinaryConnectorView" }
          ]
        }
      ]
    },
    "ClassView": {
      "$id": "#ClassView",
      "title": "Class View",
      "description": "A view element that represents the single occurrence of a class in a diagram.",
      "type": "object",
      "properties": {
        "type": {
          "title": "type",
          "description": "Determines the type of a class view object.",
          "const": "ClassView"
        },
        "rectangle": {
          "title": "rectangle",
          "description": "Identifies the rectangle shape that renders the class view in the diagram.",
          "$ref": "#/definitions/id"
        }
      },
      "required": ["type", "rectangle"]
    },
    "GeneralizationSetView": {
      "$id": "#GeneralizationSetView",
      "title": "Generalization Set View",
      "description": "A view element that represents the single occurrence of a generalization set in a diagram.",
      "type": "object",
      "properties": {
        "type": {
          "title": "type",
          "description": "Determines the type of a generalization set view object.",
          "const": "GeneralizationSetView"
        },
        "generalizations": {
          "title": "generalizations",
          "description": "Identifies the generalization views that are grouped by the generalization set view in the diagram.",
          "type": "array",
          "items": { "$ref": "#/definitions/id" }
        },
        "text": {
          "title": "text",
          "description": "Identifies the text shape that renders the generalization set view in the diagram.",
          "$ref": "#/definitions/id"
        }
      },
      "required": ["type", "generalizations", "text"]
    },
    "NaryRelationView": {
      "$id": "#NaryRelationView",
      "title": "N-ary Relation View",
      "description": "A view element that represents the single occurrence of a n-ary relation in a diagram.",
      "type": "object",
      "properties": {
        "type": {
          "title": "type",
          "description": "Determines the type of a n-ary relation view object.",
          "const": "NaryRelationView"
        },
        "members": {
          "title": "members",
          "description": "Identifies the class views (i.e., the members) that are connected by the n-ary relation view in the diagram. This array of member views must be ordered according to the properties of the relation the view represents.",
          "type": "array",
          "minItems": 3,
          "items": { "$ref": "#/definitions/id" }
        },
        "diamond": {
          "title": "diamond",
          "description": "Identifies the diamond shape that renders the joining of all paths of the n-ary relation in the diagram.",
          "$ref": "#/definitions/id"
        },
        "paths": {
          "title": "paths",
          "description": "Identifies the path shapes that render each path of the n-ary relation view in the diagram. This array of paths must be ordered according to the properties of the relation the view represents.",
          "type": "array",
          "minItems": 3,
          "items": { "$ref": "#/definitions/id" }
        }
      },
      "required": ["type", "members", "diamond", "paths"]
    },
    "NoteView": {
      "$id": "#NoteView",
      "title": "Note View",
      "description": "A view element that represents the single occurrence of a note in a diagram.",
      "type": "object",
      "properties": {
        "type": {
          "title": "type",
          "description": "Determines the type of a note view object.",
          "const": "NoteView"
        },
        "text": {
          "title": "text",
          "description": "Identifies the text shape that renders the note view in the diagram.",
          "$ref": "#/definitions/id"
        }
      },
      "required": ["type", "text"]
    },
    "PackageView": {
      "$id": "#PackageView",
      "title": "Package View",
      "description": "A view element that represents the single occurrence of a package in a diagram.",
      "type": "object",
      "properties": {
        "type": {
          "title": "type",
          "description": "Determines the type of a package view object.",
          "const": "PackageView"
        },
        "rectangle": {
          "title": "rectangle",
          "description": "Identifies the rectangle shape that renders the package view in the diagram.",
          "$ref": "#/definitions/id"
        }
      },
      "required": ["type", "rectangle"]
    },
    "BinaryConnectorView": {
      "$id": "#BinaryConnectorView",
      "title": "Binary Connector View",
      "description": "A view element that represents the single occurrence of a binary connector (e.g., a binary relation, or a generalization) in a diagram.",
      "allOf": [
        {
          "type": "object",
          "properties": {
            "sourceView": {
              "title": "source view",
              "description": "Identifies the source view the binary connector view connects in the diagram.",
              "$ref": "#/definitions/id"
            },
            "targetView": {
              "title": "target view",
              "description": "Identifies the target view the binary connector view connects in the diagram.",
              "$ref": "#/definitions/id"
            },
            "path": {
              "title": "path",
              "description": "Identifies the path shape that renders the binary connector in the diagram.",
              "$ref": "#/definitions/id"
            }
          },
          "required": ["sourceView", "targetView", "path"]
        },
        {
          "oneOf": [
            { "$ref": "#/definitions/GeneralizationView" },
            { "$ref": "#/definitions/LinkView" },
            { "$ref": "#/definitions/BinaryRelationView" }
          ]
        }
      ]
    },
    "GeneralizationView": {
      "$id": "#GeneralizationView",
      "title": "Generalization View",
      "description": "A view element that represents the single occurrence of a binary relation in a diagram.",
      "type": "object",
      "properties": {
        "type": {
          "title": "type",
          "description": "Determines the type of a generalization view object.",
          "const": "GeneralizationView"
        }
      },
      "required": ["type"]
    },
    "LinkView": {
      "$id": "#LinkView",
      "title": "Link View",
      "description": "A view element that represents the single occurrence of a link in a diagram.",
      "type": "object",
      "properties": {
        "type": {
          "title": "type",
          "description": "Determines the type of a link view object.",
          "const": "LinkView"
        }
      },
      "required": ["type"]
    },
    "BinaryRelationView": {
      "$id": "#BinaryRelationView",
      "title": "Relation View",
      "description": "A view element that represents the single occurrence of a binary relation in a diagram.",
      "type": "object",
      "properties": {
        "type": {
          "title": "type",
          "description": "Determines the type of a binary relation view object.",
          "const": "BinaryRelationView"
        }
      },
      "required": ["type"]
    },
    "Shape": {
      "$id": "#Shape",
      "title": "Shape",
      "description": "An OntoUML element that identifies how to render a view (or a portion of one) in a diagram.",
      "oneOf": [
        { "$ref": "#/definitions/Path" },
        { "$ref": "#/definitions/RectangularShape" }
      ]
    },
    "Path": {
      "$id": "#Path",
      "title": "Path",
      "description": "A shape defined by a list of points connecting two other shapes.",
      "type": "object",
      "properties": {
        "type": {
          "title": "type",
          "description": "Determines the type of a path object.",
          "const": "Path"
        },
        "points": {
          "title": "points",
          "description": "Determines the points across the path shape is rendered using an array of point objects. A path has a minimum of two points which must be ordered from the edge of the source shape to the edge of the target shape.",
          "type": "array",
          "minItems": 2,
          "items": { "$ref": "#/definitions/point" }
        }
      },
      "required": ["type", "points"]
    },
    "RectangularShape": {
      "$id": "#RectangularShape",
      "title": "Rectangular Shape",
      "description": "A shape defined by a top left position, a height, a width.",
      "allOf": [
        {
          "type": "object",
          "properties": {
            "topLeft": {
              "title": "top left",
              "description": "Determines the coordinates of the top left corner of the rectangular shape using a point object.",
              "$ref": "#/definitions/point"
            },
            "width": {
              "title": "width",
              "description": "Determines the width of the rectangular shape using a positive integer.",
              "type": "integer",
              "minimum": 0
            },
            "height": {
              "title": "height",
              "description": "Determines the height of the rectangular shape using a positive integer.",
              "type": "integer",
              "minimum": 0
            }
          },
          "required": ["topLeft", "width", "height"]
        },
        {
          "oneOf": [
            { "$ref": "#/definitions/Diamond" },
            { "$ref": "#/definitions/Rectangle" },
            { "$ref": "#/definitions/Text" }
          ]
        }
      ]
    },
    "Diamond": {
      "$id": "#Diamond",
      "title": "Diamond",
      "description": "A rectangular shape that renders the joining diamond of a n-ary relation view.",
      "type": "object",
      "properties": {
        "type": {
          "title": "type",
          "description": "Determines the type of a diamond object.",
          "const": "Diamond"
        }
      },
      "required": ["type"]
    },
    "Rectangle": {
      "$id": "#Rectangle",
      "title": "Rectangle",
      "description": "A rectangular shape that renders the shape of a class view or a package view.",
      "type": "object",
      "properties": {
        "type": {
          "title": "type",
          "description": "Determines the type of a rectangle object.",
          "const": "Rectangle"
        }
      },
      "required": ["type"]
    },
    "Text": {
      "$id": "#Text",
      "title": "Text",
      "description": "A rectangular shape that renders the shape of a generalization set view or a note view.",
      "type": "object",
      "properties": {
        "type": {
          "title": "type",
          "description": "Determines the type of a text object.",
          "const": "Text"
        }
      },
      "required": ["type"]
    },
    "PackageableElement": {
      "$id": "#PackageableElement",
      "title": "Packageable Element",
      "description": "A model element that can be grouped into a package.",
      "oneOf": [
        { "$ref": "#/definitions/Classifier" },
        { "$ref": "#/definitions/Generalization" },
        { "$ref": "#/definitions/GeneralizationSet" },
        { "$ref": "#/definitions/Link" },
        { "$ref": "#/definitions/Note" }
      ]
    },
    "id": {
      "$id": "#id",
      "title": "id",
      "description": "Determines the unique identifier for an OntoUML element in an ontology using a non-empty string.",
      "type": "string",
      "minLength": 1
    },
    "languageString": {
      "$id": "#languageString",
      "title": "language string",
      "description": "Determines an object where the key-value pairs represent, respectively, an IANA language tag and a string carrying the textual information in that language.\n\nExamples include \"{ \"en\": \"My Resource\" }\" and \"{ \"pt-BR\": \"Meu Recurso\" }\".\n\nThe empty key can be used to represent a string in an unknown language, as in \"{ \"\": \"Unknown Language Value\" }\".",
      "type": "object",
      "additionalProperties": { "type": "string", "minLength": 1 }
    },
    "resource": {
      "$id": "#resource",
      "title": "resource",
      "description": "An object that represents a reference to a resource by its name and its URI allowing references to resources in the semantic web.",
      "type": "object",
      "properties": {
        "URI": {
          "title": "URI",
          "description": "Determines the Uniform Resource Identifier (URI) of the resource using a string.",
          "oneOf": [{ "type": "null" }, { "type": "string", "format": "uri" }]
        },
        "name": {
          "title": "name",
          "description": "Determines the name of the resource using a language string.",
          "oneOf": [
            { "type": "null" },
            { "$ref": "#/definitions/languageString" }
          ]
        }
      },
      "required": ["URI", "name"]
    },
    "pointInTime": {
      "$id": "#pointInTime",
      "title": "point in time",
      "description": "Determines a point in time with the precision of a year, a month, a day, or a second.",
      "type": "string",
      "anyOf": [
        { "format": "date-time" },
        { "format": "date" },
        { "pattern": "^[0-9]{4}-(1[0-2]|0[1-9]|\\d)$" },
        { "pattern": "^([0-9]{4})$" }
      ]
    },
    "point": {
      "$id": "#point",
      "title": "point",
      "description": "A object that represents a point in a diagram through (x,y) coordinates (horizontal and vertical), where the top left corner of the diagram represents the coordinates (0,0) which increase downwards and rightwards.",
      "type": "object",
      "properties": {
        "x": {
          "title": "x",
          "description": "Determines the horizontal coordinate of a point using a positive integer.",
          "type": "integer",
          "minimum": 0
        },
        "y": {
          "title": "y",
          "description": "Determines the vertical coordinate of a point using a positive integer.",
          "type": "integer",
          "minimum": 0
        }
      },
      "required": ["x", "y"]
    }
  }
}