sdml_core/stdlib/
skos.rs

1/**
2This Rust module contains the SDML model of the SDML library module `skos` for SKOS.
3*/
4use crate::model::{
5    annotations::HasAnnotations,
6    definitions::{StructureBody, UnionBody},
7    modules::Module,
8    values::SimpleValue,
9};
10use std::str::FromStr;
11use url::Url;
12
13// ------------------------------------------------------------------------------------------------
14// Public Types
15// ------------------------------------------------------------------------------------------------
16
17pub const MODULE_PATH: &str = "::org::w3";
18pub const MODULE_NAME: &str = "skos";
19pub const MODULE_URL: &str = "http://www.w3.org/2004/02/skos/core#";
20
21pub const COLLECTION: &str = "Collection";
22pub const CONCEPT: &str = "Concept";
23pub const CONCEPT_SCHEME: &str = "ConceptScheme";
24pub const ORDERED_COLLECTION: &str = "OrderedCollection";
25
26pub const ALT_LABEL: &str = "altLabel";
27pub const BROAD_MATCH: &str = "broadMatch";
28pub const BROADER: &str = "broader";
29pub const BROADER_TRANSITIVE: &str = "broaderTransitive";
30pub const CHANGE_NOTE: &str = "changeNote";
31pub const CLOSE_MATCH: &str = "closeMatch";
32pub const DEFINITION: &str = "definition";
33pub const EDITORIAL_NOTE: &str = "editorialNote";
34pub const EXACT_MATCH: &str = "exactMatch";
35pub const EXAMPLE: &str = "example";
36pub const HAS_TOP_CONCEPT: &str = "hasTopConcept";
37pub const HIDDEN_LABEL: &str = "hiddenLabel";
38pub const HISTORY_NOTE: &str = "historyNote";
39pub const IN_SCHEME: &str = "inScheme";
40pub const MAPPING_RELATION: &str = "mappingRelation";
41pub const MEMBER: &str = "member";
42pub const MEMBER_LIST: &str = "memberList";
43pub const NARROW_MATCH: &str = "narrowMatch";
44pub const NARROWER: &str = "narrower";
45pub const NARROWER_TRANSITIVE: &str = "narrowerTransitive";
46pub const NOTATION: &str = "notation";
47pub const NOTE: &str = "note";
48pub const PREF_LABEL: &str = "prefLabel";
49pub const RELATED: &str = "related";
50pub const RELATED_MATCH: &str = "relatedMatch";
51pub const SCOPE_NOTE: &str = "scopeNote";
52pub const SEMANTIC_RELATION: &str = "semanticRelation";
53pub const TOP_CONCEPT_OF: &str = "topConceptOf";
54
55// ------------------------------------------------------------------------------------------------
56// Public Functions
57// ------------------------------------------------------------------------------------------------
58
59module_function!(|| {
60    let module_uri: url::Url = url::Url::parse(MODULE_URL).unwrap();
61
62    module!(
63        id!(unchecked skos), module_uri ; call |module: Module|
64        module.with_imports([import_statement!(
65            id!(unchecked dc),
66            id!(unchecked owl),
67            id!(unchecked rdf),
68            id!(unchecked rdfs)
69        )])
70            .with_annotations([
71                annotation!(id!(unchecked rdf:type), id!(unchecked owl:Ontology)),
72                annotation!(id!(unchecked dcterms:title), "SKOS Vocabulary"),
73                annotation!(
74                    id!(unchecked dcterms:contributor),
75                    vs!(
76                        "Dave Beckett",
77                        "Nikki Rogers",
78                        "Participants in W3C's Semantic Web Deployment Working Group."
79                    )
80                ),
81                annotation!(
82                    id!(unchecked dcterms:creator),
83                    vs!("Alistair Miles", "Sean Bechhofer")
84                ),
85                annotation!(
86                    id!(unchecked rdfs:seeAlso),
87                    Url::parse("http://www.w3.org/TR/skos-reference/").unwrap()
88                ),
89            ])
90            .with_definitions([
91                structure!(
92                    id!(unchecked Collection) ; call |body: StructureBody|
93                    body.with_annotations([
94                        annotation!(id!(unchecked rdf:type), id!(unchecked owl:Class)),
95                        annotation!(
96                            id!(unchecked owl:disjointWith),
97                            vs!(id!(unchecked Concept), id!(unchecked ConceptScheme))
98                        ),
99                        annotation!(id!(unchecked rdfs:isDefinedBy), id!(unchecked skos)),
100                        annotation!(id!(unchecked rdfs:label), rdf_str!("Collection"@en)),
101                        annotation!(
102                            id!(unchecked definition),
103                            rdf_str!("A meaningful collection of concepts."@en)
104                        ),
105                        annotation!(
106                            id!(unchecked scopeNote),
107                            rdf_str!(
108                                "Labelled collections can be used where you would like a set of concepts to be displayed under a 'node label' in the hierarchy."@en
109                            )
110                        ),
111                    ])).into(),
112                structure!(
113                    id!(unchecked Concept) ; call |body: StructureBody|
114                    body.with_annotations([
115                        annotation!(id!(unchecked rdf:type), id!(unchecked owl:Class)),
116                        annotation!(id!(unchecked rdfs:isDefinedBy), id!(unchecked skos)),
117                        annotation!(id!(unchecked rdfs:label), rdf_str!("Concept"@en)),
118                        annotation!(
119                            id!(unchecked definition),
120                            rdf_str!("An idea or notion; a unit of thought."@en)
121                        ),
122                    ])).into(),
123                structure!(
124                    id!(unchecked ConceptScheme) ; call |body: StructureBody|
125                    body.with_annotations([
126                        annotation!(id!(unchecked rdf:type), id!(unchecked owl:Class)),
127                        annotation!(id!(unchecked rdfs:isDefinedBy), id!(unchecked skos)),
128                        annotation!(id!(unchecked rdfs:label), rdf_str!("Concept Scheme"@en)),
129                        annotation!(
130                            id!(unchecked definition),
131                            rdf_str!("A set of concepts, optionally including statements about semantic relationships between those concepts."@en)
132                        ),
133                        annotation!(
134                            id!(unchecked example),
135                            rdf_str!("Thesauri, classification schemes, subject heading lists, taxonomies, 'folksonomies', and other types of controlled vocabulary are all examples of concept schemes. Concept schemes are also embedded in glossaries and terminologies."@en)
136                        ),
137                        annotation!(
138                            id!(unchecked scopeNote),
139                            rdf_str!("A concept scheme may be defined to include concepts from different sources."@en)
140                        ),
141                    ])).into(),
142                structure!(
143                    id!(unchecked OrderedCollection) ; call |body: StructureBody|
144                    body.with_annotations([
145                        annotation!(id!(unchecked rdf:type), id!(unchecked owl:Class)),
146                        annotation!(id!(unchecked rdfs:subClassOf), id!(unchecked Collection)),
147                        annotation!(id!(unchecked rdfs:isDefinedBy), id!(unchecked skos)),
148                        annotation!(id!(unchecked rdfs:label), rdf_str!("Ordered Collection"@en)),
149                        annotation!(
150                            id!(unchecked definition),
151                            rdf_str!("An ordered collection of concepts, where both the grouping and the ordering are meaningful."@en)
152                        ),
153                        annotation!(
154                            id!(unchecked scopeNote),
155                            rdf_str!("Ordered collections can be used where you would like a set of concepts to be displayed in a specific order, and optionally under a 'node label'."@en)
156                        ),
157                    ])).into(),
158                property!(
159                    id!(unchecked altLabel) => { cardinality!(0..) } id!(unchecked owl:Thing) ;
160                    annotation_body!(
161                        annotation!(id!(unchecked rdf:type), vs!(
162                            id!(unchecked rdf:Property),
163                            id!(unchecked owl:AnnotationProperty),
164                        )),
165                        annotation!(id!(unchecked rdfs:subPropertyOf), id!(unchecked rdfs:label)),
166                        annotation!(id!(unchecked rdfs:isDefinedBy), id!(unchecked skos)),
167                        annotation!(id!(unchecked rdfs:label), rdf_str!("alternative label"@en)),
168                        annotation!(
169                            id!(unchecked definition),
170                            rdf_str!("An alternative lexical label for a resource."@en)
171                        ),
172                        annotation!(
173                            id!(unchecked rdfs:comment),
174                            vs!(
175                                rdf_str!("The range of skos:altLabel is the class of RDF plain literals."@en),
176                                rdf_str!("skos:prefLabel, skos:altLabel and skos:hiddenLabel are pairwise disjoint properties."@en),
177                            )
178                        ),
179                        annotation!(
180                            id!(unchecked example),
181                            rdf_str!("Acronyms, abbreviations, spelling variants, and irregular plural/singular forms may be included among the alternative labels for a concept. Mis-spelled terms are normally included as hidden labels (see skos:hiddenLabel)."@en)
182                        ),
183                    )).into(),
184                property!(
185                    id!(unchecked broadMatch) => { cardinality!(0..) } id!(unchecked owl:Thing) ;
186                    annotation_body!(
187                        annotation!(id!(unchecked rdf:type), vs!(
188                            id!(unchecked rdf:Property),
189                            id!(unchecked owl:ObjectProperty),
190                        )),
191                        annotation!(id!(unchecked rdfs:subPropertyOf), id!(unchecked broader)),
192                        annotation!(id!(unchecked rdfs:subPropertyOf), id!(unchecked mappingRelation)),
193                        annotation!(id!(unchecked owl:inverseOf), id!(unchecked narrowMatch)),
194                        annotation!(id!(unchecked rdfs:isDefinedBy), id!(unchecked skos)),
195                        annotation!(id!(unchecked rdfs:label), rdf_str!("has broader match"@en)),
196                        annotation!(
197                            id!(unchecked definition),
198                            rdf_str!("skos:broadMatch is used to state a hierarchical mapping link between two conceptual resources in different concept schemes."@en)
199                        ),
200                    )).into(),
201                property!(
202                    id!(unchecked broader) => { cardinality!(0..) } id!(unchecked owl:Thing) ;
203                    annotation_body!(
204                        annotation!(id!(unchecked rdf:type), vs!(
205                            id!(unchecked rdf:Property),
206                            id!(unchecked owl:ObjectProperty),
207                        )),
208                        annotation!(id!(unchecked rdfs:subPropertyOf), id!(unchecked broaderTransitive)),
209                        annotation!(id!(unchecked owl:inverseOf), id!(unchecked narrower)),
210                        annotation!(id!(unchecked rdfs:isDefinedBy), id!(unchecked skos)),
211                        annotation!(id!(unchecked rdfs:label), rdf_str!("has broader"@en)),
212                        annotation!(
213                            id!(unchecked definition),
214                            rdf_str!("Relates a concept to a concept that is more general in meaning."@en)
215                        ),
216                        annotation!(
217                            id!(unchecked scopeNote),
218                            rdf_str!("By convention, skos:broader is only used to assert an immediate (i.e. direct) hierarchical link between two conceptual resources."@en)
219                        ),
220                    )).into(),
221                property!(
222                    id!(unchecked broaderTransitive) => { cardinality!(0..) } id!(unchecked owl:Thing) ;
223                    annotation_body!(
224                        annotation!(id!(unchecked rdf:type), vs!(
225                            id!(unchecked rdf:Property),
226                            id!(unchecked owl:ObjectProperty),
227                            id!(unchecked owl:TransitiveProperty),
228                        )),
229                        annotation!(id!(unchecked rdfs:subPropertyOf), id!(unchecked semanticRelation)),
230                        annotation!(id!(unchecked owl:inverseOf), id!(unchecked narrowerTransitive)),
231                        annotation!(id!(unchecked rdfs:isDefinedBy), id!(unchecked skos)),
232                        annotation!(id!(unchecked rdfs:label), rdf_str!("has broader transitive"@en)),
233                        annotation!(
234                            id!(unchecked definition),
235                            rdf_str!("skos:broaderTransitive is a transitive superproperty of skos:broader."@en)
236                        ),
237                        annotation!(
238                            id!(unchecked scopeNote),
239                            rdf_str!("By convention, skos:broaderTransitive is not used to make assertions. Rather, the properties can be used to draw inferences about the transitive closure of the hierarchical relation, which is useful e.g. when implementing a simple query expansion algorithm in a search application."@en)
240                        ),
241                    )).into(),
242                property!(
243                    id!(unchecked changeNote) => { cardinality!(0..) } id!(unchecked owl:Thing) ;
244                    annotation_body!(
245                        annotation!(id!(unchecked rdf:type), vs!(
246                            id!(unchecked rdf:Property),
247                            id!(unchecked owl:AnnotationProperty),
248                        )),
249                        annotation!(id!(unchecked rdfs:subPropertyOf), id!(unchecked note)),
250                        annotation!(id!(unchecked owl:inverseOf), id!(unchecked narrowerTransitive)),
251                        annotation!(id!(unchecked rdfs:isDefinedBy), id!(unchecked skos)),
252                        annotation!(id!(unchecked rdfs:label), rdf_str!("change note"@en)),
253                        annotation!(
254                            id!(unchecked definition),
255                            rdf_str!("A note about a modification to a concept."@en)
256                        ),
257                    )).into(),
258                property!(
259                    id!(unchecked closeMatch) => { cardinality!(0..) } id!(unchecked owl:Thing) ;
260                    annotation_body!(
261                        annotation!(id!(unchecked rdf:type), vs!(
262                            id!(unchecked rdf:Property),
263                            id!(unchecked owl:ObjectProperty),
264                            id!(unchecked owl:SymmetricProperty),
265                        )),
266                        annotation!(id!(unchecked rdfs:subPropertyOf), id!(unchecked mappingRelation)),
267                        annotation!(id!(unchecked rdfs:isDefinedBy), id!(unchecked skos)),
268                        annotation!(id!(unchecked rdfs:label), rdf_str!("has close match"@en)),
269                        annotation!(
270                            id!(unchecked definition),
271                            rdf_str!("skos:closeMatch is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications. In order to avoid the possibility of \"compound errors\" when combining mappings across more than two concept schemes, skos:closeMatch is not declared to be a transitive property."@en)
272                        ),
273                    )).into(),
274                property!(
275                    id!(unchecked definition) => { cardinality!(0..) } id!(unchecked owl:Thing) ;
276                    annotation_body!(
277                        annotation!(id!(unchecked rdf:type), vs!(
278                            id!(unchecked rdf:Property),
279                            id!(unchecked owl:AnnotationProperty),
280                        )),
281                        annotation!(id!(unchecked rdfs:subPropertyOf), id!(unchecked note)),
282                        annotation!(id!(unchecked rdfs:isDefinedBy), id!(unchecked skos)),
283                        annotation!(id!(unchecked rdfs:label), rdf_str!("definition"@en)),
284                        annotation!(
285                            id!(unchecked definition),
286                            rdf_str!("A statement or formal explanation of the meaning of a concept."@en)
287                        ),
288                    )).into(),
289                property!(
290                    id!(unchecked editorialNote) => { cardinality!(0..) } id!(unchecked owl:Thing) ;
291                    annotation_body!(
292                        annotation!(id!(unchecked rdf:type), vs!(
293                            id!(unchecked rdf:Property),
294                            id!(unchecked owl:AnnotationProperty),
295                        )),
296                        annotation!(id!(unchecked rdfs:subPropertyOf), id!(unchecked note)),
297                        annotation!(id!(unchecked rdfs:isDefinedBy), id!(unchecked skos)),
298                        annotation!(id!(unchecked rdfs:label), rdf_str!("editorial note"@en)),
299                        annotation!(
300                            id!(unchecked definition),
301                            rdf_str!("A note for an editor, translator or maintainer of the vocabulary."@en)
302                        ),
303                    )).into(),
304                property!(
305                    id!(unchecked exactMatch) => { cardinality!(0..) } id!(unchecked owl:Thing) ;
306                    annotation_body!(
307                        annotation!(id!(unchecked rdf:type), vs!(
308                            id!(unchecked rdf:Property),
309                            id!(unchecked owl:ObjectProperty),
310                            id!(unchecked owl:SymmetricProperty),
311                            id!(unchecked owl:TransitiveProperty),
312                        )),
313                        annotation!(id!(unchecked rdfs:subPropertyOf), id!(unchecked closeMatch)),
314                        annotation!(id!(unchecked rdfs:isDefinedBy), id!(unchecked skos)),
315                        annotation!(id!(unchecked rdfs:label), rdf_str!("has exact match"@en)),
316                        annotation!(
317                            id!(unchecked definition),
318                            rdf_str!("skos:exactMatch is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications. skos:exactMatch is a transitive property, and is a sub-property of skos:closeMatch."@en)
319                        ),
320                    )).into(),
321                property!(
322                    id!(unchecked hasTopConcept) => { cardinality!(0..) } id!(unchecked ConceptScheme) ;
323                    annotation_body!(
324                        annotation!(id!(unchecked rdf:type), vs!(
325                            id!(unchecked rdf:Property),
326                            id!(unchecked owl:ObjectProperty),
327                        )),
328                        annotation!(id!(unchecked rdfs:domain), id!(unchecked Concept)),
329                        annotation!(id!(unchecked rdfs:subPropertyOf), id!(unchecked closeMatch)),
330                        annotation!(id!(unchecked owl:inverseOf), id!(unchecked topConceptOf)),
331                        annotation!(id!(unchecked rdfs:isDefinedBy), id!(unchecked skos)),
332                        annotation!(id!(unchecked rdfs:label), rdf_str!("has top concept"@en)),
333                        annotation!(
334                            id!(unchecked definition),
335                            rdf_str!("Relates, by convention, a concept scheme to a concept which is topmost in the broader/narrower concept hierarchies for that scheme, providing an entry point to these hierarchies."@en)
336                        ),
337                    )).into(),
338                property!(
339                    id!(unchecked hiddenLabel) => { cardinality!(0..) } id!(unchecked owl:Thing) ;
340                    annotation_body!(
341                        annotation!(id!(unchecked rdf:type), vs!(
342                            id!(unchecked rdf:Property),
343                            id!(unchecked owl:AnnotationProperty),
344                        )),
345                        annotation!(id!(unchecked rdfs:subPropertyOf), id!(unchecked rdfs:label)),
346                        annotation!(id!(unchecked rdfs:isDefinedBy), id!(unchecked skos)),
347                        annotation!(id!(unchecked rdfs:label), rdf_str!("hidden label"@en)),
348                        annotation!(
349                            id!(unchecked definition),
350                            rdf_str!("A lexical label for a resource that should be hidden when generating visual displays of the resource, but should still be accessible to free text search operations."@en)
351                        ),
352                    )).into(),
353                property!(
354                    id!(unchecked historyNote) => { cardinality!(0..) } id!(unchecked owl:Thing) ;
355                    annotation_body!(
356                        annotation!(id!(unchecked rdf:type), vs!(
357                            id!(unchecked rdf:Property),
358                            id!(unchecked owl:AnnotationProperty),
359                        )),
360                        annotation!(id!(unchecked rdfs:subPropertyOf), id!(unchecked note)),
361                        annotation!(id!(unchecked rdfs:isDefinedBy), id!(unchecked skos)),
362                        annotation!(id!(unchecked rdfs:label), rdf_str!("history note"@en)),
363                        annotation!(
364                            id!(unchecked definition),
365                            rdf_str!("A note about the past state/use/meaning of a concept."@en)
366                        ),
367                    )).into(),
368                property!(
369                    id!(unchecked inScheme) => { cardinality!(0..) } id!(unchecked ConceptScheme) ;
370                    annotation_body!(
371                        annotation!(id!(unchecked rdf:type), vs!(
372                            id!(unchecked rdf:Property),
373                            id!(unchecked owl:ObjectProperty),
374                        )),
375                        annotation!(id!(unchecked rdfs:isDefinedBy), id!(unchecked skos)),
376                        annotation!(id!(unchecked rdfs:label), rdf_str!("is in scheme"@en)),
377                        annotation!(
378                            id!(unchecked definition),
379                            rdf_str!("Relates a resource (for example a concept) to a concept scheme in which it is included."@en)
380                        ),
381                        annotation!(
382                            id!(unchecked scopeNote),
383                            rdf_str!("A concept may be a member of more than one concept scheme."@en)
384                        ),
385                    )).into(),
386                property!(
387                    id!(unchecked mappingRelation) => { cardinality!(0..) } id!(unchecked owl:Thing) ;
388                    annotation_body!(
389                        annotation!(id!(unchecked rdf:type), vs!(
390                            id!(unchecked rdf:Property),
391                            id!(unchecked owl:ObjectProperty),
392                        )),
393                        annotation!(id!(unchecked rdfs:subPropertyOf), id!(unchecked semanticRelation)),
394                        annotation!(id!(unchecked rdfs:isDefinedBy), id!(unchecked skos)),
395                        annotation!(id!(unchecked rdfs:label), rdf_str!("is in mapping relation with"@en)),
396                        annotation!(
397                            id!(unchecked definition),
398                            rdf_str!("Relates two concepts coming, by convention, from different schemes, and that have comparable meanings."@en)
399                        ),
400                        annotation!(
401                            id!(unchecked rdfs:comment),
402                            rdf_str!("These concept mapping relations mirror semantic relations, and the data model defined below is similar (with the exception of skos:exactMatch) to the data model defined for semantic relations. A distinct vocabulary is provided for concept mapping relations, to provide a convenient way to differentiate links within a concept scheme from links between concept schemes. However, this pattern of usage is not a formal requirement of the SKOS data model, and relies on informal definitions of best practice."@en)
403                        ),
404                    )).into(),
405                union!(
406                    id!(unchecked CollectionMember) ; call |body: UnionBody|
407                    body.with_variants([
408                        unvar!(id!(unchecked Concept)),
409                        unvar!(id!(unchecked Collection)),
410                    ])).into(),
411                property!(
412                    id!(unchecked member) => { cardinality!(0..) } id!(unchecked CollectionMember) ;
413                    annotation_body!(
414                        annotation!(id!(unchecked rdf:type), vs!(
415                            id!(unchecked rdf:Property),
416                            id!(unchecked owl:ObjectProperty),
417                        )),
418                        annotation!(id!(unchecked rdfs:domain), id!(unchecked Collection)),
419                        annotation!(id!(unchecked rdfs:isDefinedBy), id!(unchecked skos)),
420                        annotation!(id!(unchecked rdfs:label), rdf_str!("has member"@en)),
421                        annotation!(
422                            id!(unchecked definition),
423                            rdf_str!("Relates a collection to one of its members."@en)
424                        ),
425                    )).into(),
426                property!(
427                    id!(unchecked memberList) => { cardinality!(0..) } id!(unchecked rdf:List) ;
428                    annotation_body!(
429                        annotation!(id!(unchecked rdf:type), vs!(
430                            id!(unchecked rdf:Property),
431                            id!(unchecked owl:FunctionalProperty),
432                            id!(unchecked owl:ObjectProperty),
433                        )),
434                        annotation!(id!(unchecked rdfs:domain), id!(unchecked OrderedCollection)),
435                        annotation!(id!(unchecked rdfs:isDefinedBy), id!(unchecked skos)),
436                        annotation!(id!(unchecked rdfs:label), rdf_str!("has member list"@en)),
437                        annotation!(
438                            id!(unchecked definition),
439                            rdf_str!("Relates an ordered collection to the RDF list containing its member."@en)
440                        ),
441                        annotation!(
442                            id!(unchecked rdfs:comment),
443                            rdf_str!("For any resource, every item in the list given as the value of the skos:memberList property is also a value of the skos:member property."@en)
444                        ),
445                    )).into(),
446                property!(
447                    id!(unchecked narrowMatch) => { cardinality!(0..) } id!(unchecked owl:Thing) ;
448                    annotation_body!(
449                        annotation!(id!(unchecked rdf:type), vs!(
450                            id!(unchecked rdf:Property),
451                            id!(unchecked owl:ObjectProperty),
452                        )),
453                        annotation!(id!(unchecked rdfs:subPropertyOf), vs!(
454                            id!(unchecked mappingRelation),
455                            id!(unchecked narrower)
456                        )),
457                        annotation!(id!(unchecked owl:inverseOf), id!(unchecked broadMatch)),
458                        annotation!(id!(unchecked rdfs:isDefinedBy), id!(unchecked skos)),
459                        annotation!(id!(unchecked rdfs:label), rdf_str!("has narrower match"@en)),
460                        annotation!(
461                            id!(unchecked definition),
462                            rdf_str!("skos:narrowMatch is used to state a hierarchical mapping link between two conceptual resources in different concept schemes."@en)
463                        ),
464                    )).into(),
465                property!(
466                    id!(unchecked narrower) => { cardinality!(0..) } id!(unchecked owl:Thing) ;
467                    annotation_body!(
468                        annotation!(id!(unchecked rdf:type), vs!(
469                            id!(unchecked rdf:Property),
470                            id!(unchecked owl:ObjectProperty),
471                        )),
472                        annotation!(id!(unchecked rdfs:subPropertyOf), id!(unchecked narrowerTransitive)),
473                        annotation!(id!(unchecked owl:inverseOf), id!(unchecked broader)),
474                        annotation!(id!(unchecked rdfs:isDefinedBy), id!(unchecked skos)),
475                        annotation!(id!(unchecked rdfs:label), rdf_str!("has narrower"@en)),
476                        annotation!(
477                            id!(unchecked definition),
478                            rdf_str!("Relates a concept to a concept that is more specific in meaning."@en)
479                        ),
480                        annotation!(
481                            id!(unchecked rdfs:comment),
482                            rdf_str!("Narrower concepts are typically rendered as children in a concept hierarchy (tree)."@en)
483                        ),
484                    )).into(),
485                property!(
486                    id!(unchecked narrowerTransitive) => { cardinality!(0..) } id!(unchecked owl:Thing) ;
487                    annotation_body!(
488                        annotation!(id!(unchecked rdf:type), vs!(
489                            id!(unchecked rdf:Property),
490                            id!(unchecked owl:ObjectProperty),
491                            id!(unchecked owl:TransitiveProperty),
492                        )),
493                        annotation!(id!(unchecked rdfs:subPropertyOf), id!(unchecked semanticRelation)),
494                        annotation!(id!(unchecked owl:inverseOf), id!(unchecked broaderTransitive)),
495                        annotation!(id!(unchecked rdfs:isDefinedBy), id!(unchecked skos)),
496                        annotation!(id!(unchecked rdfs:label), rdf_str!("has narrower transitive"@en)),
497                        annotation!(
498                            id!(unchecked definition),
499                            rdf_str!("skos:narrowerTransitive is a transitive superproperty of skos:narrower."@en)
500                        ),
501                        annotation!(
502                            id!(unchecked scopeNote),
503                            rdf_str!("By convention, skos:narrowerTransitive is not used to make assertions. Rather, the properties can be used to draw inferences about the transitive closure of the hierarchical relation, which is useful e.g. when implementing a simple query expansion algorithm in a search application."@en)
504                        ),
505                    )).into(),
506                property!(
507                    id!(unchecked notation) => { cardinality!(0..) } id!(unchecked owl:Thing) ;
508                    annotation_body!(
509                        annotation!(id!(unchecked rdf:type), vs!(
510                            id!(unchecked rdf:Property),
511                            id!(unchecked owl:DatatypeProperty),
512                        )),
513                        annotation!(id!(unchecked rdfs:isDefinedBy), id!(unchecked skos)),
514                        annotation!(id!(unchecked rdfs:label), rdf_str!("notation"@en)),
515                        annotation!(
516                            id!(unchecked definition),
517                            rdf_str!("A notation, also known as classification code, is a string of characters such as \"T58.5\" or \"303.4833\" used to uniquely identify a concept within the scope of a given concept scheme."@en)
518                        ),
519                        annotation!(
520                            id!(unchecked scopeNote),
521                            rdf_str!("By convention, skos:notation is used with a typed literal in the object position of the triple."@en)
522                        ),
523                    )).into(),
524                property!(
525                    id!(unchecked note) => { cardinality!(0..) } id!(unchecked owl:Thing) ;
526                    annotation_body!(
527                        annotation!(id!(unchecked rdf:type), vs!(
528                            id!(unchecked rdf:Property),
529                            id!(unchecked owl:AnnotationProperty),
530                        )),
531                        annotation!(id!(unchecked rdfs:isDefinedBy), id!(unchecked skos)),
532                        annotation!(id!(unchecked rdfs:label), rdf_str!("note"@en)),
533                        annotation!(
534                            id!(unchecked definition),
535                            rdf_str!("A general note, for any purpose."@en)
536                        ),
537                        annotation!(
538                            id!(unchecked scopeNote),
539                            rdf_str!("This property may be used directly, or as a super-property for more specific note types."@en)
540                        ),
541                    )).into(),
542                property!(
543                    id!(unchecked prefLabel) => { cardinality!(0..) } id!(unchecked owl:Thing) ;
544                    annotation_body!(
545                        annotation!(id!(unchecked rdf:type), vs!(
546                            id!(unchecked rdf:Property),
547                            id!(unchecked owl:AnnotationProperty),
548                        )),
549                        annotation!(id!(unchecked rdfs:subPropertyOf), id!(unchecked rdfs:label)),
550                        annotation!(id!(unchecked rdfs:isDefinedBy), id!(unchecked skos)),
551                        annotation!(id!(unchecked rdfs:label), rdf_str!("preferred label"@en)),
552                        annotation!(
553                            id!(unchecked definition),
554                            rdf_str!("The preferred lexical label for a resource, in a given language."@en)
555                        ),
556                        annotation!(
557                            id!(unchecked rdfs:comment),
558                            vs!(
559                                rdf_str!("A resource has no more than one value of skos:prefLabel per language tag, and no more than one value of skos:prefLabel without language tag."@en),
560                                rdf_str!("The range of skos:prefLabel is the class of RDF plain literals."@en),
561                                rdf_str!("skos:prefLabel, skos:altLabel and skos:hiddenLabel are pairwise disjoint properties."@en),
562                            )),
563                    )).into(),
564                property!(
565                    id!(unchecked related) => { cardinality!(0..) } id!(unchecked owl:Thing) ;
566                    annotation_body!(
567                        annotation!(id!(unchecked rdf:type), vs!(
568                            id!(unchecked rdf:Property),
569                            id!(unchecked owl:ObjectProperty),
570                            id!(unchecked owl:SymmetricProperty),
571                        )),
572                        annotation!(id!(unchecked rdfs:subPropertyOf), id!(unchecked semanticRelation)),
573                        annotation!(id!(unchecked rdfs:isDefinedBy), id!(unchecked skos)),
574                        annotation!(id!(unchecked rdfs:label), rdf_str!("has related"@en)),
575                        annotation!(
576                            id!(unchecked definition),
577                            rdf_str!("Relates a concept to a concept with which there is an associative semantic relationship."@en)
578                        ),
579                        annotation!(
580                            id!(unchecked rdfs:comment),
581                            rdf_str!("skos:related is disjoint with skos:broaderTransitive."@en)
582                        ),
583                    )).into(),
584                property!(
585                    id!(unchecked relatedMatch) => { cardinality!(0..) } id!(unchecked owl:Thing) ;
586                    annotation_body!(
587                        annotation!(id!(unchecked rdf:type), vs!(
588                            id!(unchecked rdf:Property),
589                            id!(unchecked owl:ObjectProperty),
590                            id!(unchecked owl:SymmetricProperty),
591                        )),
592                        annotation!(id!(unchecked rdfs:subPropertyOf), vs!(
593                            id!(unchecked mappingRelation),
594                            id!(unchecked related),
595                        )),
596                        annotation!(id!(unchecked rdfs:isDefinedBy), id!(unchecked skos)),
597                        annotation!(id!(unchecked rdfs:label), rdf_str!("has related match"@en)),
598                        annotation!(
599                            id!(unchecked definition),
600                            rdf_str!("skos:relatedMatch is used to state an associative mapping link between two conceptual resources in different concept schemes."@en)
601                        ),
602                    )).into(),
603                property!(
604                    id!(unchecked scopeNote) => { cardinality!(0..) } id!(unchecked owl:Thing) ;
605                    annotation_body!(
606                        annotation!(id!(unchecked rdf:type), vs!(
607                            id!(unchecked rdf:Property),
608                            id!(unchecked owl:AnnotationProperty),
609                        )),
610                        annotation!(id!(unchecked rdfs:subPropertyOf), id!(unchecked note)),
611                        annotation!(id!(unchecked rdfs:isDefinedBy), id!(unchecked skos)),
612                        annotation!(id!(unchecked rdfs:label), rdf_str!("scope note"@en)),
613                        annotation!(
614                            id!(unchecked definition),
615                            rdf_str!("A note that helps to clarify the meaning and/or the use of a concept."@en)
616                        ),
617                    )).into(),
618                property!(
619                    id!(unchecked semanticRelation) => { cardinality!(0..) } id!(unchecked Concept) ;
620                    annotation_body!(
621                        annotation!(id!(unchecked rdf:type), vs!(
622                            id!(unchecked rdf:Property),
623                            id!(unchecked owl:ObjectProperty),
624                        )),
625                        annotation!(id!(unchecked rdfs:domain), id!(unchecked Concept)),
626                        annotation!(id!(unchecked owl:inverseOf), id!(unchecked broaderTransitive)),
627                        annotation!(id!(unchecked rdfs:isDefinedBy), id!(unchecked skos)),
628                        annotation!(id!(unchecked rdfs:label), rdf_str!("is in semantic relation with"@en)),
629                        annotation!(
630                            id!(unchecked definition),
631                            rdf_str!("Links a concept to a concept related by meaning."@en)
632                        ),
633                        annotation!(
634                            id!(unchecked scopeNote),
635                            rdf_str!("This property should not be used directly, but as a super-property for all properties denoting a relationship of meaning between concepts."@en)
636                        ),
637                    )).into(),
638                property!(
639                    id!(unchecked topConceptOf) => { cardinality!(0..) } id!(unchecked ConceptScheme) ;
640                    annotation_body!(
641                        annotation!(id!(unchecked rdf:type), vs!(
642                            id!(unchecked rdf:Property),
643                            id!(unchecked owl:ObjectProperty),
644                            id!(unchecked owl:TransitiveProperty),
645                        )),
646                        annotation!(id!(unchecked rdfs:domain), id!(unchecked Concept)),
647                        annotation!(id!(unchecked rdfs:subPropertyOf), id!(unchecked inScheme)),
648                        annotation!(id!(unchecked owl:inverseOf), id!(unchecked hasTopConcept)),
649                        annotation!(id!(unchecked rdfs:isDefinedBy), id!(unchecked skos)),
650                        annotation!(id!(unchecked rdfs:label), rdf_str!("is top concept in scheme"@en)),
651                        annotation!(
652                            id!(unchecked definition),
653                            rdf_str!("Relates a concept to the concept scheme that it is a top level concept of."@en)
654                        ),
655                    )).into(),
656            ])
657    )
658});