A specific (physical) manifestation conceptual entity.
A list of terms from different schemas or terminology systems that have narrower meaning.
Qualifies relationships between a subject `Thing` and an object `Thing` with a `Statement` declaring a `predicate` on the nature of the relationship.
A list of terms from different schemas or terminology systems that have close meaning.
A list of terms from different schemas or terminology systems that have broader meaning.
Persistent and globally unique identifier of a `Thing`.
A record of properties of the metadata record on a subject, a collection of tag/text tuples with the semantics of OWL Annotation.
Label that can be shown when the metadata record is displayed as an item.
A list of terms from different schemas or terminology systems that have identical meaning.
The resource that the subject is a distribution of.
A relation of an information artifact to the subject, such as a URL identifying the topic of a document.
A comment about a metadata record either providing additional information for a record curation, or leaving a comment after curation occurred. This can be used to include information that is deemed relevant, but could not be expressed in the provided fields.
An unambiguous reference to the subject within a given context.
State that the subject is an instance of a particular schema class. Typically, no explicit value needs to be assigned to this slot, because it matches the class type of a particular record. However, this slots can be used as a type designator of a schema element for validation and schema structure handling purposes. This is used to indicate specialized schema classes for properties that accept a hierarchy of classes as their range.
Declares an unqualified relation of the subject `Thing` to another `Thing`. This schema slot is used to define related things inline. If such a definition is not needed. A qualified relationship can be declared directly using the `characterized_by` slot.
A list of terms from different schemas or terminology systems that have related meaning.
Declares a relation that associates a `Thing` (or another attribute) with an attribute, where an attribute is an intrinsic characteristic, such as a quality, capability, disposition, function, or is an externally derived attribute determined from some descriptor (e.g. a quantity, position, label/identifier). Technically, this declaration is done via an `AttributeSpecification` that combines a `predicate` with a value declaration and the attribute-related slots of a `Thing`. Importantly, such attributes are declared inline, because they do not have a unique identifier. If an identifier is available, a `Thing` declaration (see `relation`), and a qualification of that relationship via a `Statement` (see `characterized_by`) should be preferred.
Note that can be shown when the record is displayed as an item. This is typically longer than a label.
Mix-in with the common interface of `Thing` and `AttributeSpecification`. This interface enables type specifications (`rdf:type`) for things and attributes via a `type` designator slot to indicate specialized schema classes for validation where a slot's `range` is too generic. A thing or attribute can be further describe with statements on qualified relations to other things (`characterized_by`), or inline attributes (`attributes`). A set of `mappings` slots enables the alignment for arbitrary external schemas and terminologies.
A `Thing` that is a value of some kind. This class can be used to describe an outcome of a measurement, a factual value or constant, or other qualitative or quantitative information with an associated identifier. If no identifier is available, an `AttributeSpecification` can be used within the context of an associated `Thing` (`attributes`).
Declares that the value of a `Thing` or `AttributeSpecification` are instances of a particular class.
Indicate a resource defining the subject. This may be a vocabulary that describes the subject.
A unit of measurement is a standardized quantity of a physical quality.
Value that is a direct representation of a thing.
Mix-in for a (structured) value specification. Two slots are provided to define a (literal) value (`value`) and its type (`range`).
A Checksum is a value that allows to check the integrity of the contents of a file. Even small changes to the content of the file will change its checksum. This class allows the results of a variety of checksum and cryptographic message digest algorithms to be represented.
Identifies the software agent (algorithm) used to produce the subject `Checksum`.
Lower case hexadecimal encoded checksum digest value.
An association class for attaching a `locator` as additional information to a `hasPart` relationship between two files.
Reference to a `Thing` within a `Statement`.
Describes the function of an entity or agent (object) within the scope of a relationship with the subject.
A specific representation of a data item in the form of an electronic file. The concept of a file here is aligned with the broad UNIX philoshopy of "everything is a file". An archive, a disk image, a directory are all valid instances of a file.
The checksum property provides a mechanism that can be used to verify that the contents of a file or package have not changed.
The entity that the subject is a part of. A core relation that holds between a part and its whole.
A related resource that is included either physically or logically in the described resource.
The media type of a distribution as defined by IANA
An RDF property, a `Thing` used to define a `predicate`, for example in a `Statement`.
A tag/value pair with the semantics of OWL Annotation.
An attribute is conceptually a thing, but it requires no dedicated identifier (`pid`). Instead, it is linked to a `Thing` via its `attributes` slot and declares a `predicate` on the nature of the relationship.
Reference to a `Property` within a `Statement`.
An identifier is a label that uniquely identifies an item in a particular context. Some identifiers are globally unique. All identifiers are unique within their individual scope.
String of characters such as "T58:5" or "30:4833" used to uniquely identify a concept within the scope of a given concept scheme.
An agent responsible for making an entity.
An RDF statement that links a `predicate` (a `Property`) with an `object` (a `Thing`) to the subject to form a triple. A `Statement` is used to qualify a relation to a `Thing` referenced by its identifier. For specifying a qualified relation to an attribute that has no dedicated identifier, use an `AttributeSpecification`.
The most basic, identifiable item. In addition to the slots that are common between a `Thing` and an `AttributeSpecification` (see `ThingMixin`), two additional slots are provided. The `pid` slot takes the required identifier for a `Thing`. The `relation` slot allows for the inline specification of other `Thing` instances. Such a relation is unqualified (and symmetric), and should be further characterized via a `Statement` (see `characterized_by`). From a schema perspective, the `relation` slots allows for building self-contained, structured documents (e.g., a JSON object) with arbitrarily complex information on a `Thing`.