glossarist 0.4.18 → 0.4.20

package/src/models/related-concept.js

@@ -25,6 +25,11 @@ export const RELATIONSHIP_TYPES = Object.freeze([
   // Associative (ISO 10241-1 / ISO 25964)
   'see', 'related_concept', 'related_concept_broader', 'related_concept_narrower',
   'references',
+  // ExternalConcept resolution (Glossarist extension — v2 partitive-relation)
+  // Direction: real concept `provides` substance for an external concept;
+  // external concept `provided_by` real concept. Stored on the
+  // ExternalConcept. See TODO.partitive-relation-v2 item 07.
+  'provides', 'provided_by',
   // Comparative (ISO 10241-1)
   'compare', 'contrast',
   // Spatiotemporal (ISO 25964 / TBX)
@@ -37,12 +42,21 @@ export class RelatedConcept extends GlossaristModel {
   constructor(data = {}) {
     super();
     this.type = data.type ?? 'see';
-    this.content = data.content ?? null;
+    this.content = normalizeContent(data.content);
     this.ref = data.ref
       ? (data.ref instanceof ConceptRef ? data.ref : new ConceptRef(data.ref))
       : null;
   }
 
+  // Convenience reader: returns the first available string value
+  // from the localized hash, or null if absent. Mirrors
+  // PartitiveHyperedge#contentString.
+  get contentString() {
+    if (!this.content) return null;
+    const values = Object.values(this.content);
+    return values.length > 0 ? values[0] : null;
+  }
+
   toJSON() {
     const obj = { type: this.type };
     if (this.content != null) obj.content = this.content;
@@ -50,7 +64,30 @@ export class RelatedConcept extends GlossaristModel {
     return obj;
   }
 
+  static identityOf(value) {
+    const v = value ?? {};
+    const ref = v?.ref;
+    return `${v.type ?? ''}|${ref?.source ?? ''}|${ref?.id ?? ''}`;
+  }
+
+  identity() {
+    return RelatedConcept.identityOf(this);
+  }
+
   static fromJSON(data) {
     return new RelatedConcept(data);
   }
 }
+
+// Content is a localized string (language → text). Plain strings on
+// input are normalized to `{ default: '...' }` so callers always see
+// the same shape. Mirrors PartitiveHyperedge's normalizeContent.
+function normalizeContent(value) {
+  if (value == null) return null;
+  if (typeof value === 'string') return { default: value };
+  if (typeof value === 'object') {
+    const entries = Object.entries(value).filter(([, v]) => typeof v === 'string');
+    return entries.length > 0 ? Object.fromEntries(entries) : null;
+  }
+  return null;
+}

package/src/models/relation-categories.js

@@ -96,6 +96,11 @@ export const RELATION_CATEGORIES = Object.freeze({
   // (a version IS a definitional variant of the same concept identity).
   // Renaming aligns glossarist-js with the canonical taxonomy at
   // concept-browser:src/data/taxonomies.json.
+  //
+  // `provides` / `provided_by` (Glossarist v2 extension) live here too:
+  // they record ExternalConcept resolution — a definitional linkage
+  // between a placeholder and the concept that fills its substance.
+  // See TODO.partitive-relation-v2 item 07.
   definitional: Object.freeze({
     label: 'Definitional',
     description: 'ISO 19135 concept-to-concept relations: definition, part, instance, inheritance, versioning.',
@@ -107,6 +112,7 @@ export const RELATION_CATEGORIES = Object.freeze({
       'inherits', 'inherited_by',
       'has_version', 'version_of',
       'current_version', 'current_version_of',
+      'provides', 'provided_by',
     ]),
   }),
 });

package/src/models/type-shared-plurality.js

@@ -0,0 +1,71 @@
+// TypeSharedPlurality — semantic claims encoded by ISO 704's
+// close-set double line and broken line notation, promoted from
+// diagram-notation flags to structured data.
+//
+//   is_shared    — ISO 704 close-set double line. True when several
+//                  partitives of a given type are involved.
+//   is_uncertain — ISO 704 broken line. True when the type-shared
+//                  plurality is uncertain (asserted to exist but its
+//                  boundaries are not firmly established).
+//                  Defaults to false when omitted.
+//   shared_type  — Glossarist extension. The type the partitives
+//                  share, when known. ISO notation does not encode
+//                  this; left for the reader to infer. Optional even
+//                  when is_shared is true.
+//
+// A PartitiveRelation has at most one TypeSharedPlurality block.
+// Absent means: no type-shared plurality claim is being made.
+//
+// Replaces the v1 `markers: [double, dashed]` field per
+// TODO.partitive-relation-v2 item 03.
+
+import { GlossaristModel } from './base.js';
+import { ConceptRef } from './concept-ref.js';
+
+export class TypeSharedPlurality extends GlossaristModel {
+  constructor(data = {}) {
+    super();
+    if (typeof data.isShared !== 'boolean' && typeof data.is_shared !== 'boolean') {
+      throw new Error(
+        'TypeSharedPlurality requires isShared (boolean); got: ' +
+        `${JSON.stringify(data.isShared ?? data.is_shared)}`,
+      );
+    }
+    this.isShared = data.isShared ?? data.is_shared;
+    this.isUncertain = data.isUncertain ?? data.is_uncertain ?? false;
+    this.sharedType = data.sharedType
+      ? (data.sharedType instanceof ConceptRef ? data.sharedType : new ConceptRef(data.sharedType))
+      : null;
+
+    _validate(this);
+  }
+
+  hasSharedType() {
+    return this.sharedType != null;
+  }
+
+  toJSON() {
+    const obj = { is_shared: this.isShared };
+    if (this.isUncertain) obj.is_uncertain = this.isUncertain;
+    if (this.sharedType != null) obj.shared_type = this.sharedType.toJSON();
+    return obj;
+  }
+
+  static fromJSON(data) {
+    return new TypeSharedPlurality(data);
+  }
+}
+
+function _validate(plurality) {
+  if (typeof plurality.isShared !== 'boolean') {
+    throw new Error('TypeSharedPlurality.isShared must be boolean');
+  }
+  if (typeof plurality.isUncertain !== 'boolean') {
+    throw new Error('TypeSharedPlurality.isUncertain must be boolean');
+  }
+  // ISO 704 semantic check: a broken line qualifies the close-set
+  // double-line plurality claim. is_uncertain without is_shared is
+  // semantically odd. The model accepts it (data is data); the
+  // PartitiveRelationCoherenceRule surfaces it as a warning so
+  // reviewers can decide whether the data shape is intentional.
+}

package/src/rdf/gloss-concept.js

@@ -7,6 +7,8 @@ import { PRED } from './predicates.js';
 import { WELL_KNOWN } from './prefixes.js';
 import { localizedConceptToQuads } from './gloss-localized-concept.js';
 import { conceptSourceToQuads } from './gloss-source.js';
+import { partitiveRelationToQuads, partitiveRelationSubjectUri } from './gloss-partitive-relation.js';
+import { hyperedgeToQuads, hyperedgeSubjectUri } from './gloss-hyperedge.js';
 import { namedNode, literal, quad } from './terms.js';
 
 // Kind tag → URI segment. Each NonVerbalReference subtype has a
@@ -69,4 +71,28 @@ export function* conceptToQuads(concept, options) {
     yield* conceptSourceToQuads(source, { subjectUri, index: srcIndex });
     srcIndex += 1;
   }
+
+  // v2 canonical: concept.partitiveRelations. v1 alias
+  // (concept.partitiveHyperedges) points at the same array — both
+  // work here.
+  const relations = concept.partitiveRelations ?? concept.partitiveHyperedges ?? [];
+  let relIdx = 0;
+  for (const relation of relations) {
+    // Skip v1 PartitiveHyperedge instances — they have their own
+    // emitter (gloss-hyperedge.js) and would double-emit. The parser
+    // always produces v2 PartitiveRelation instances; only direct
+    // callers using the v1 model would see this branch.
+    const isV2 = !relation.enumeration && !relation.markers && !relation.parts
+      || (relation.completeness != null || relation.partitives != null);
+    if (!isV2) {
+      const heSubject = hyperedgeSubjectUri(subjectUri, relation, relIdx);
+      yield quad(s, namedNode(PRED.gloss.hasPartitiveHyperedge), namedNode(heSubject));
+      yield* hyperedgeToQuads(relation, { parentUri: subjectUri, index: relIdx });
+    } else {
+      const relSubject = partitiveRelationSubjectUri(subjectUri, relation, relIdx);
+      yield quad(s, namedNode(PRED.gloss.hasPartitiveRelation), namedNode(relSubject));
+      yield* partitiveRelationToQuads(relation, { parentUri: subjectUri, index: relIdx });
+    }
+    relIdx += 1;
+  }
 }

package/src/rdf/gloss-hyperedge.js

@@ -0,0 +1,90 @@
+// PartitiveHyperedge → RDF quads.
+//
+// Shape (per concept-model ontology, v3.1.0):
+//   <base>/hyperedge/<carrying-id>/<comprehensive-id>
+//     rdf:type                    gloss:PartitiveHyperedge
+//     gloss:comprehensive         <base>/concept/<comprehensive-id>
+//     gloss:hasPart               <base>/concept/<part-id>        (one per part)
+//     gloss:enumeration           "closed"|"open"                 (literal)
+//     gloss:hasPluralityMarker    "double"|"dashed"               (literal, one per marker)
+//     gloss:hyperedgeContent      "..."                           (literal, omitted if absent)
+//
+// The carrying concept links to this hyperedge via `gloss:hasPartitiveHyperedge`
+// (emitted by gloss-concept.js#conceptToQuads).
+//
+// CROSS-REPO STATUS (validated 2026-07-22):
+//   - Subject URI scheme: matches Ruby (`hyperedge/<c>/<comp>`).
+//   - `comprehensive`, `enumeration`, `hasPluralityMarker`, `hyperedgeContent`:
+//     predicates + object types match Ruby.
+//   - `hasPart`: JS follows the concept-model ontology; Ruby emits
+//     `gloss:part` instead. This is a Ruby bug — tracked as a cross-repo
+//     follow-up. Once Ruby aligns with the ontology, output will be
+//     byte-equivalent (modulo serialization order).
+
+import { PRED } from './predicates.js';
+import { WELL_KNOWN } from './prefixes.js';
+import { namedNode, literal, quad } from './terms.js';
+
+export function* hyperedgeToQuads(hyperedge, { parentUri, index }) {
+  const heSubject = hyperedgeSubjectUri(parentUri, hyperedge, index);
+  const s = namedNode(heSubject);
+
+  yield quad(s, namedNode(WELL_KNOWN.rdfType), namedNode(PRED.gloss.PartitiveHyperedge));
+
+  const comp = hyperedge.comprehensive;
+  if (comp && (comp.source || comp.id)) {
+    yield quad(s, namedNode(PRED.gloss.comprehensive),
+      namedNode(conceptRefUri(comp, parentUri)));
+  }
+
+  const parts = Array.isArray(hyperedge.parts) ? hyperedge.parts : [];
+  for (const p of parts) {
+    if (p && (p.source || p.id)) {
+      yield quad(s, namedNode(PRED.gloss.hasPart),
+        namedNode(conceptRefUri(p, parentUri)));
+    }
+  }
+
+  if (hyperedge.enumeration) {
+    yield quad(s, namedNode(PRED.gloss.enumeration), literal(hyperedge.enumeration));
+  }
+
+  for (const marker of Array.isArray(hyperedge.markers) ? hyperedge.markers : []) {
+    yield quad(s, namedNode(PRED.gloss.hasPluralityMarker), literal(marker));
+  }
+
+  if (hyperedge.content) {
+    const content = hyperedge.content;
+    if (typeof content === 'string') {
+      yield quad(s, namedNode(PRED.gloss.hyperedgeContent), literal(content));
+    } else if (typeof content === 'object') {
+      for (const [lang, text] of Object.entries(content)) {
+        if (typeof text !== 'string') continue;
+        yield quad(s, namedNode(PRED.gloss.hyperedgeContent), literal(text, lang));
+      }
+    }
+  }
+}
+
+// Subject URI scheme: `<base>/hyperedge/<carrying-id>/<comprehensive-id>`.
+// Matches Ruby's `subject { |h| "hyperedge/#{h.identifier}/#{h.comprehensive_id}" }`.
+// Falls back to an index suffix if comprehensive has no id, so two
+// hyperedges on the same concept never collide.
+export function hyperedgeSubjectUri(parentUri, hyperedge, index) {
+  const base = parentUri.replace(/\/concept\/[^/]+$/, '');
+  const carrierId = parentUri.split('/concept/')[1] ?? `carrier-${index}`;
+  const compId = hyperedge?.comprehensive?.id ?? `comp-${index}`;
+  return `${base}/hyperedge/${carrierId}/${compId}`;
+}
+
+// ConceptRef URI: `<base>/concept/<id>`. Matches Ruby's
+// `concept_to_gloss_transform.rb#hyperedge_concept_uri`. Source is
+// dropped from the URI; it stays on the ConceptRef object if needed.
+function conceptRefUri(ref, parentUri) {
+  const id = ref?.id;
+  if (id) {
+    const base = parentUri.split('/concept/')[0];
+    return `${base}/concept/${id}`;
+  }
+  return `urn:glossarist:${ref?.source ?? 'unknown'}:`;
+}

package/src/rdf/gloss-partitive-relation.js

@@ -0,0 +1,109 @@
+// PartitiveRelation → RDF quads.
+//
+// Shape (per concept-model ontology, v3.2.0):
+//
+//   <base>/partitive-relation/<carrying-id>/<comprehensive-id>
+//     rdf:type                       gloss:PartitiveRelation
+//     gloss:comprehensive            <base>/concept/<comprehensive-id>      (named node)
+//     gloss:hasPartitive             <base>/concept/<partitive-id>         (named node, one per member)
+//     gloss:completeness             "complete"|"partial"                   (literal)
+//     gloss:hasPlurality             <plurality bnode>                      (when plurality present)
+//     gloss:criterion                "..."@lang                             (one per language, when present)
+//
+// Plurality bnode (when present):
+//
+//   _:b<n>
+//     rdf:type                       gloss:TypeSharedPlurality
+//     gloss:isShared                 true|false                             (literal)
+//     gloss:isUncertain              true|false                             (literal, when non-default)
+//     gloss:sharedType               <base>/concept/<shared-type-id>        (when shared_type present)
+//
+// The carrying concept links via `gloss:hasPartitiveRelation`.
+//
+// Replaces gloss-hyperedge.js (the v1 emitter) per TODO.partitive-relation-v2 item 01.
+// Cross-repo alignment with glossarist-ruby's Rdf::GlossPartitiveRelation.
+
+import { PRED } from './predicates.js';
+import { WELL_KNOWN } from './prefixes.js';
+import { deterministicBnode } from './deterministic-id.js';
+import { namedNode, literal, quad } from './terms.js';
+
+export function* partitiveRelationToQuads(relation, { parentUri, index }) {
+  const subjectUri = partitiveRelationSubjectUri(parentUri, relation, index);
+  const s = namedNode(subjectUri);
+
+  yield quad(s, namedNode(WELL_KNOWN.rdfType), namedNode(PRED.gloss.PartitiveRelation));
+
+  const comp = relation.comprehensive;
+  if (comp && (comp.source || comp.id)) {
+    yield quad(s, namedNode(PRED.gloss.comprehensive),
+      namedNode(conceptRefUri(comp, parentUri)));
+  }
+
+  const members = Array.isArray(relation.partitives) ? relation.partitives : [];
+  for (const member of members) {
+    const ref = member?.ref ?? member;
+    if (!ref || (!ref.source && !ref.id)) continue;
+    yield quad(s, namedNode(PRED.gloss.hasPartitive),
+      namedNode(conceptRefUri(ref, parentUri)));
+  }
+
+  if (relation.completeness) {
+    yield quad(s, namedNode(PRED.gloss.completeness), literal(relation.completeness));
+  }
+
+  if (relation.plurality != null) {
+    const pSubject = deterministicBnode(subjectUri, 'plurality', 0);
+    yield quad(s, namedNode(PRED.gloss.hasPlurality), namedNode(pSubject));
+    yield* pluralityToQuads(relation.plurality, pSubject);
+  }
+
+  if (relation.criterion && typeof relation.criterion === 'object') {
+    for (const [lang, text] of Object.entries(relation.criterion)) {
+      if (typeof text !== 'string') continue;
+      yield quad(s, namedNode(PRED.gloss.criterion), literal(text, lang));
+    }
+  }
+}
+
+function* pluralityToQuads(plurality, subjectUri) {
+  const s = namedNode(subjectUri);
+  yield quad(s, namedNode(WELL_KNOWN.rdfType), namedNode(PRED.gloss.TypeSharedPlurality));
+  yield quad(s, namedNode(PRED.gloss.isShared), literal(plurality.isShared ? 'true' : 'false', 'xsd:boolean'));
+  if (plurality.isUncertain) {
+    yield quad(s, namedNode(PRED.gloss.isUncertain), literal('true', 'xsd:boolean'));
+  }
+  if (plurality.sharedType) {
+    // sharedType is a ConceptRef-like object; emit as a concept URI.
+    // We don't have parentUri here, but sharedType typically points at
+    // an external concept. Fall back to urn form.
+    const st = plurality.sharedType;
+    const uri = st.id
+      ? `urn:glossarist:${st.source ?? 'unknown'}:${st.id}`
+      : `urn:glossarist:${st.source ?? 'unknown'}:`;
+    yield quad(s, namedNode(PRED.gloss.sharedType), namedNode(uri));
+  }
+}
+
+// Subject URI scheme: `<base>/partitive-relation/<carrying-id>/<comprehensive-id>`.
+// Matches the Ruby emitter's scheme. Falls back to an index suffix if
+// the comprehensive has no id, so two relations on the same concept
+// never collide.
+export function partitiveRelationSubjectUri(parentUri, relation, index) {
+  const base = parentUri.replace(/\/concept\/[^/]+$/, '');
+  const carrierId = parentUri.split('/concept/')[1] ?? `carrier-${index}`;
+  const compId = relation?.comprehensive?.id ?? `comp-${index}`;
+  return `${base}/partitive-relation/${carrierId}/${compId}`;
+}
+
+// ConceptRef URI resolution: `<base>/concept/<id>` for any ref with an
+// id. Source is dropped (matches Ruby). Falls back to a stable urn:/
+// form for refs with only a source (rare).
+function conceptRefUri(ref, parentUri) {
+  const id = ref?.id;
+  if (id) {
+    const base = parentUri.split('/concept/')[0];
+    return `${base}/concept/${id}`;
+  }
+  return `urn:glossarist:${ref?.source ?? 'unknown'}:`;
+}

package/src/rdf/gloss-source.js

@@ -30,7 +30,7 @@ export function* conceptSourceToQuads(source, { subjectUri, index }) {
     yield* citationToQuads(source.origin, { subjectUri: srcSubject, predicate: PRED.gloss.sourceOrigin, bnodeKey: 'origin' });
   }
 
-  const sourcedFrom = source.sourced_from ?? [];
+  const sourcedFrom = source.sourcedFrom ?? source.sourced_from ?? [];
   for (let i = 0; i < sourcedFrom.length; i++) {
     yield* citationToQuads(sourcedFrom[i], { subjectUri: srcSubject, predicate: PRED.gloss.sourcedFrom, bnodeKey: 'sourced_from', index: i });
   }

package/src/rdf/index.d.ts

@@ -11,6 +11,7 @@ import type { Designation } from '../models/index';
 import type { DetailedDefinition } from '../models/index';
 import type { ConceptSource } from '../models/index';
 import type { NonVerbRep, Figure, Table, Formula } from '../models/index';
+import type { PartitiveHyperedge, PartitiveRelation } from '../models/index';
 
 export { PRED, PREFIXES } from './predicates';
 export type PredicateMap = typeof PRED;
@@ -77,6 +78,42 @@ export interface ConceptSourceEmitOptions {
 
 export declare function conceptSourceToQuads(source: ConceptSource, options: ConceptSourceEmitOptions): Generator<Quad, void, unknown>;
 
+// ── Hyperedge emitter ─────────────────────────────────────────────────
+
+export interface HyperedgeEmitOptions {
+  parentUri: string;
+  index: number;
+}
+
+export declare function hyperedgeToQuads(
+  hyperedge: PartitiveHyperedge,
+  options: HyperedgeEmitOptions,
+): Generator<Quad, void, unknown>;
+
+export declare function hyperedgeSubjectUri(
+  parentUri: string,
+  hyperedge: PartitiveHyperedge,
+  index: number,
+): string;
+
+// ── PartitiveRelation emitter (v2) ────────────────────────────────────
+
+export interface PartitiveRelationEmitOptions {
+  parentUri: string;
+  index: number;
+}
+
+export declare function partitiveRelationToQuads(
+  relation: PartitiveRelation,
+  options: PartitiveRelationEmitOptions,
+): Generator<Quad, void, unknown>;
+
+export declare function partitiveRelationSubjectUri(
+  parentUri: string,
+  relation: PartitiveRelation,
+  index: number,
+): string;
+
 // ── Non-verbal representation emitters ─────────────────────────────────
 
 export interface NonVerbalRepEmitOptions {

package/src/rdf/index.js

@@ -26,6 +26,8 @@ export {
 } from './gloss-designation.js';
 export { detailedDefinitionToQuads } from './gloss-detailed-definition.js';
 export { conceptSourceToQuads } from './gloss-source.js';
+export { hyperedgeToQuads, hyperedgeSubjectUri } from './gloss-hyperedge.js';
+export { partitiveRelationToQuads, partitiveRelationSubjectUri } from './gloss-partitive-relation.js';
 export {
   nonVerbalRepToQuads,
   nonVerbalEntityToQuads,

package/src/rdf/predicates.d.ts

@@ -23,6 +23,9 @@ export declare const PRED = {
     "ConceptRef": "https://www.glossarist.org/ontologies/ConceptRef",
     "Reference": "https://www.glossarist.org/ontologies/Reference",
     "RelatedConcept": "https://www.glossarist.org/ontologies/RelatedConcept",
+    "PartitiveHyperedge": "https://www.glossarist.org/ontologies/PartitiveHyperedge",
+    "PartitiveEnumeration": "https://www.glossarist.org/ontologies/PartitiveEnumeration",
+    "PluralityMarker": "https://www.glossarist.org/ontologies/PluralityMarker",
     "DesignationRelationship": "https://www.glossarist.org/ontologies/DesignationRelationship",
     "ConceptDate": "https://www.glossarist.org/ontologies/ConceptDate",
     "NonVerbalRepresentation": "https://www.glossarist.org/ontologies/NonVerbalRepresentation",
@@ -42,6 +45,7 @@ export declare const PRED = {
     "isLocalizationOf": "https://www.glossarist.org/ontologies/isLocalizationOf",
     "hasStatus": "https://www.glossarist.org/ontologies/hasStatus",
     "hasDomain": "https://www.glossarist.org/ontologies/hasDomain",
+    "tag": "https://www.glossarist.org/ontologies/tag",
     "hasRelatedConcept": "https://www.glossarist.org/ontologies/hasRelatedConcept",
     "hasDate": "https://www.glossarist.org/ontologies/hasDate",
     "hasSource": "https://www.glossarist.org/ontologies/hasSource",
@@ -93,7 +97,30 @@ export declare const PRED = {
     "relationshipType": "https://www.glossarist.org/ontologies/relationshipType",
     "relationshipContent": "https://www.glossarist.org/ontologies/relationshipContent",
     "relationshipRef": "https://www.glossarist.org/ontologies/relationshipRef",
+    "relatedConceptBroader": "https://www.glossarist.org/ontologies/relatedConceptBroader",
+    "relatedConceptNarrower": "https://www.glossarist.org/ontologies/relatedConceptNarrower",
+    "hasPartitiveHyperedge": "https://www.glossarist.org/ontologies/hasPartitiveHyperedge",
+    "comprehensive": "https://www.glossarist.org/ontologies/comprehensive",
+    "hasPart": "https://www.glossarist.org/ontologies/hasPart",
+    "enumeration": "https://www.glossarist.org/ontologies/enumeration",
+    "hasPluralityMarker": "https://www.glossarist.org/ontologies/hasPluralityMarker",
+    "hyperedgeContent": "https://www.glossarist.org/ontologies/hyperedgeContent",
+    "PartitiveRelation": "https://www.glossarist.org/ontologies/PartitiveRelation",
+    "PartitiveMember": "https://www.glossarist.org/ontologies/PartitiveMember",
+    "TypeSharedPlurality": "https://www.glossarist.org/ontologies/TypeSharedPlurality",
+    "hasPartitiveRelation": "https://www.glossarist.org/ontologies/hasPartitiveRelation",
+    "hasPartitive": "https://www.glossarist.org/ontologies/hasPartitive",
+    "completeness": "https://www.glossarist.org/ontologies/completeness",
+    "hasPlurality": "https://www.glossarist.org/ontologies/hasPlurality",
+    "isShared": "https://www.glossarist.org/ontologies/isShared",
+    "isUncertain": "https://www.glossarist.org/ontologies/isUncertain",
+    "sharedType": "https://www.glossarist.org/ontologies/sharedType",
+    "criterion": "https://www.glossarist.org/ontologies/criterion",
+    "certainty": "https://www.glossarist.org/ontologies/certainty",
+    "provides": "https://www.glossarist.org/ontologies/provides",
+    "providedBy": "https://www.glossarist.org/ontologies/providedBy",
     "refType": "https://www.glossarist.org/ontologies/refType",
+    "source": "https://www.glossarist.org/ontologies/source",
     "urn": "https://www.glossarist.org/ontologies/urn",
     "term": "https://www.glossarist.org/ontologies/term",
     "refId": "https://www.glossarist.org/ontologies/refId",
@@ -282,6 +309,9 @@ export type Predicate =
   | "https://www.glossarist.org/ontologies/ConceptRef"
   | "https://www.glossarist.org/ontologies/Reference"
   | "https://www.glossarist.org/ontologies/RelatedConcept"
+  | "https://www.glossarist.org/ontologies/PartitiveHyperedge"
+  | "https://www.glossarist.org/ontologies/PartitiveEnumeration"
+  | "https://www.glossarist.org/ontologies/PluralityMarker"
   | "https://www.glossarist.org/ontologies/DesignationRelationship"
   | "https://www.glossarist.org/ontologies/ConceptDate"
   | "https://www.glossarist.org/ontologies/NonVerbalRepresentation"
@@ -301,6 +331,7 @@ export type Predicate =
   | "https://www.glossarist.org/ontologies/isLocalizationOf"
   | "https://www.glossarist.org/ontologies/hasStatus"
   | "https://www.glossarist.org/ontologies/hasDomain"
+  | "https://www.glossarist.org/ontologies/tag"
   | "https://www.glossarist.org/ontologies/hasRelatedConcept"
   | "https://www.glossarist.org/ontologies/hasDate"
   | "https://www.glossarist.org/ontologies/hasSource"
@@ -352,7 +383,30 @@ export type Predicate =
   | "https://www.glossarist.org/ontologies/relationshipType"
   | "https://www.glossarist.org/ontologies/relationshipContent"
   | "https://www.glossarist.org/ontologies/relationshipRef"
+  | "https://www.glossarist.org/ontologies/relatedConceptBroader"
+  | "https://www.glossarist.org/ontologies/relatedConceptNarrower"
+  | "https://www.glossarist.org/ontologies/hasPartitiveHyperedge"
+  | "https://www.glossarist.org/ontologies/comprehensive"
+  | "https://www.glossarist.org/ontologies/hasPart"
+  | "https://www.glossarist.org/ontologies/enumeration"
+  | "https://www.glossarist.org/ontologies/hasPluralityMarker"
+  | "https://www.glossarist.org/ontologies/hyperedgeContent"
+  | "https://www.glossarist.org/ontologies/PartitiveRelation"
+  | "https://www.glossarist.org/ontologies/PartitiveMember"
+  | "https://www.glossarist.org/ontologies/TypeSharedPlurality"
+  | "https://www.glossarist.org/ontologies/hasPartitiveRelation"
+  | "https://www.glossarist.org/ontologies/hasPartitive"
+  | "https://www.glossarist.org/ontologies/completeness"
+  | "https://www.glossarist.org/ontologies/hasPlurality"
+  | "https://www.glossarist.org/ontologies/isShared"
+  | "https://www.glossarist.org/ontologies/isUncertain"
+  | "https://www.glossarist.org/ontologies/sharedType"
+  | "https://www.glossarist.org/ontologies/criterion"
+  | "https://www.glossarist.org/ontologies/certainty"
+  | "https://www.glossarist.org/ontologies/provides"
+  | "https://www.glossarist.org/ontologies/providedBy"
   | "https://www.glossarist.org/ontologies/refType"
+  | "https://www.glossarist.org/ontologies/source"
   | "https://www.glossarist.org/ontologies/urn"
   | "https://www.glossarist.org/ontologies/term"
   | "https://www.glossarist.org/ontologies/refId"

package/src/rdf/predicates.js

@@ -23,6 +23,9 @@ export const PRED = {
     "ConceptRef": "https://www.glossarist.org/ontologies/ConceptRef",
     "Reference": "https://www.glossarist.org/ontologies/Reference",
     "RelatedConcept": "https://www.glossarist.org/ontologies/RelatedConcept",
+    "PartitiveHyperedge": "https://www.glossarist.org/ontologies/PartitiveHyperedge",
+    "PartitiveEnumeration": "https://www.glossarist.org/ontologies/PartitiveEnumeration",
+    "PluralityMarker": "https://www.glossarist.org/ontologies/PluralityMarker",
     "DesignationRelationship": "https://www.glossarist.org/ontologies/DesignationRelationship",
     "ConceptDate": "https://www.glossarist.org/ontologies/ConceptDate",
     "NonVerbalRepresentation": "https://www.glossarist.org/ontologies/NonVerbalRepresentation",
@@ -42,6 +45,7 @@ export const PRED = {
     "isLocalizationOf": "https://www.glossarist.org/ontologies/isLocalizationOf",
     "hasStatus": "https://www.glossarist.org/ontologies/hasStatus",
     "hasDomain": "https://www.glossarist.org/ontologies/hasDomain",
+    "tag": "https://www.glossarist.org/ontologies/tag",
     "hasRelatedConcept": "https://www.glossarist.org/ontologies/hasRelatedConcept",
     "hasDate": "https://www.glossarist.org/ontologies/hasDate",
     "hasSource": "https://www.glossarist.org/ontologies/hasSource",
@@ -93,7 +97,30 @@ export const PRED = {
     "relationshipType": "https://www.glossarist.org/ontologies/relationshipType",
     "relationshipContent": "https://www.glossarist.org/ontologies/relationshipContent",
     "relationshipRef": "https://www.glossarist.org/ontologies/relationshipRef",
+    "relatedConceptBroader": "https://www.glossarist.org/ontologies/relatedConceptBroader",
+    "relatedConceptNarrower": "https://www.glossarist.org/ontologies/relatedConceptNarrower",
+    "hasPartitiveHyperedge": "https://www.glossarist.org/ontologies/hasPartitiveHyperedge",
+    "comprehensive": "https://www.glossarist.org/ontologies/comprehensive",
+    "hasPart": "https://www.glossarist.org/ontologies/hasPart",
+    "enumeration": "https://www.glossarist.org/ontologies/enumeration",
+    "hasPluralityMarker": "https://www.glossarist.org/ontologies/hasPluralityMarker",
+    "hyperedgeContent": "https://www.glossarist.org/ontologies/hyperedgeContent",
+    "PartitiveRelation": "https://www.glossarist.org/ontologies/PartitiveRelation",
+    "PartitiveMember": "https://www.glossarist.org/ontologies/PartitiveMember",
+    "TypeSharedPlurality": "https://www.glossarist.org/ontologies/TypeSharedPlurality",
+    "hasPartitiveRelation": "https://www.glossarist.org/ontologies/hasPartitiveRelation",
+    "hasPartitive": "https://www.glossarist.org/ontologies/hasPartitive",
+    "completeness": "https://www.glossarist.org/ontologies/completeness",
+    "hasPlurality": "https://www.glossarist.org/ontologies/hasPlurality",
+    "isShared": "https://www.glossarist.org/ontologies/isShared",
+    "isUncertain": "https://www.glossarist.org/ontologies/isUncertain",
+    "sharedType": "https://www.glossarist.org/ontologies/sharedType",
+    "criterion": "https://www.glossarist.org/ontologies/criterion",
+    "certainty": "https://www.glossarist.org/ontologies/certainty",
+    "provides": "https://www.glossarist.org/ontologies/provides",
+    "providedBy": "https://www.glossarist.org/ontologies/providedBy",
     "refType": "https://www.glossarist.org/ontologies/refType",
+    "source": "https://www.glossarist.org/ontologies/source",
     "urn": "https://www.glossarist.org/ontologies/urn",
     "term": "https://www.glossarist.org/ontologies/term",
     "refId": "https://www.glossarist.org/ontologies/refId",