@faubulous/mentor-rdf 2.3.0 → 2.5.0

package/dist/ontologies/xsd.d.ts

@@ -2,9 +2,23 @@ import { NamedNode } from '@rdfjs/types';
 /** Namespace URI of the XSD vocabulary. */
 export declare const _XSD = "http://www.w3.org/2001/XMLSchema#";
 export declare const XSD: {
-    /** anyURI represents an Internationalized Resource Identifier Reference (IRI).  An anyURI value can be absolute or relative, and may have an optional fragment identifier (i.e., it may be an IRI Reference).  This type should be used when the value fulfills the role of an IRI, as defined in [RFC 3987] or its successor(s) in the IETF Standards Track. */
+    /** ENTITY represents the ENTITY attribute type from [XML].  The ·value space· of ENTITY is the set of all strings that ·match· the NCName production in [Namespaces in XML] and have been declared as an unparsed entity in a document type definition. The ·lexical space· of ENTITY is the set of all strings that ·match· the NCName production in [Namespaces in XML]. The ·base type· of ENTITY is NCName.  */
+    ENTITY: string;
+    /** ID represents the ID attribute type from [XML].  The ·value space· of ID is the set of all strings that ·match· the NCName production in [Namespaces in XML].  The ·lexical space· of ID is the set of all strings that ·match· the NCName production in [Namespaces in XML]. The ·base type· of ID is NCName. */
+    ID: string;
+    /**  IDREF represents the IDREF attribute type from [XML]. The ·value space· of IDREF is the set of all strings that ·match· the NCName production in [Namespaces in XML].  The ·lexical space· of IDREF is the set of strings that ·match· the NCName production in [Namespaces in XML]. The ·base type· of IDREF is NCName. */
+    IDREF: string;
+    NCName: string;
+    /** NMTOKEN represents the NMTOKEN attribute type from [XML]. The ·value space· of NMTOKEN is the set of tokens that ·match· the Nmtoken production in [XML]. The ·lexical space· of NMTOKEN is the set of strings that ·match· the Nmtoken production in [XML]. The ·base type· of NMTOKEN is token. */
+    NMTOKEN: string;
+    Name: string;
+    /** QName represents XML qualified names. The ·value space· of QName is the set of tuples {namespace name, local part}, where namespace name is an anyURI and local part is an NCName. The ·lexical space· of QName is the set of strings that ·match· the QName production of [Namespaces in XML]. */
+    QName: string;
+    /** The base class of any primitive XSD dataype. */
+    anySimpleType: string;
+    /** anyURI represents an Internationalized Resource Identifier Reference (IRI). An anyURI value can be absolute or relative, and may have an optional fragment identifier (i.e., it may be an IRI Reference).  This type should be used when the value fulfills the role of an IRI, as defined in [RFC 3987] or its successor(s) in the IETF Standards Track. */
     anyURI: string;
-    /** base64Binary represents arbitrary Base64-encoded binary data.  For base64Binary data the entire binary stream is encoded using the Base64 Encoding defined in [RFC 3548], which is derived from the encoding described in [RFC 2045]. */
+    /** base64Binary represents arbitrary Base64-encoded binary data. For base64Binary data the entire binary stream is encoded using the Base64 Encoding defined in [RFC 3548], which is derived from the encoding described in [RFC 2045]. */
     base64Binary: string;
     /** boolean represents the values of two-valued logic. */
     boolean: string;
@@ -14,6 +28,8 @@ export declare const XSD: {
     date: string;
     /** dateTime represents instants of time, optionally marked with a particular time zone offset.  Values representing the same instant but having different time zone offsets are equal but not identical. */
     dateTime: string;
+    /** The dateTimeStamp datatype is ·derived· from dateTime by giving the value required to its explicitTimezone facet. The result is that all values of dateTimeStamp are required to have explicit time zone offsets and the datatype is totally ordered. */
+    dateTimeStamp: string;
     /** decimal represents a subset of the real numbers, which can be represented by decimal numerals. The ·value space· of decimal is the set of numbers that can be obtained by dividing an integer by a non-negative power of ten, i.e., expressible as i / 10n where i and n are integers and n ≥ 0. Precision is not reflected in this value space; the number 2.0 is not distinct from the number 2.00. The order relation on decimal is the order relation on real numbers, restricted to this subset. */
     decimal: string;
     /** The double datatype is patterned after the IEEE double-precision 64-bit floating point datatype [IEEE 754-2008].  Each floating point datatype has a value space that is a subset of the rational numbers.  Floating point numbers are often used to approximate arbitrary real numbers. */
@@ -22,17 +38,47 @@ export declare const XSD: {
     duration: string;
     /** The float datatype is patterned after the IEEE single-precision 32-bit floating point datatype [IEEE 754-2008].  Its value space is a subset of the rational numbers.  Floating point numbers are often used to approximate arbitrary real numbers. */
     float: string;
+    /** fractionDigits controls the size of the minimum difference between values in the value space of datatypes derived from decimal, by restricting the value space to numbers that are expressible as i x 10^-n where i and n are integers and 0 <= n <= fractionDigits. */
+    fractionDigits: string;
+    gDay: string;
+    gMonth: string;
+    gMonthDay: string;
+    gYear: string;
+    gYearMonth: string;
+    /** Hex-encoded arbitrary binary data. */
+    hexBinary: string;
     /** int is ·derived· from long by setting the value of ·maxInclusive· to be 2147483647 and ·minInclusive· to be -2147483648.  The ·base type· of int is long. */
     int: string;
     /** integer is ·derived· from decimal by fixing the value of ·fractionDigits· to be 0 and disallowing the trailing decimal point.  This results in the standard mathematical concept of the integer numbers.  The ·value space· of integer is the infinite set {...,-2,-1,0,1,2,...}.  The ·base type· of integer is decimal. */
     integer: string;
+    /** llanguage represents natural language identifiers as defined by by [RFC 3066] . The ·value space· of language is the set of all strings that are valid language identifiers as defined [RFC 3066] . The ·lexical space· of language is the set of all strings that conform to the pattern [a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})* . The ·base type· of language is token. */
+    language: string;
+    /** length is the number of units of length, where units of length varies depending on the type that is being derived from. */
+    length: string;
     /** long is ·derived· from integer by setting the value of ·maxInclusive· to be 9223372036854775807 and ·minInclusive· to be -9223372036854775808. The ·base type· of long is integer. */
     long: string;
+    /** maxExclusive is the exclusive upper bound of the value space for a datatype with the ordered property. The value of maxExclusive must be in the value space of the base type or be equal to {value} in {base type definition}. */
+    maxExclusive: string;
+    /** maxInclusive is the inclusive upper bound of the value space for a datatype with the ordered property. The value of maxInclusive must be in the value space of the base type. */
+    maxInclusive: string;
+    /** minLength is the minimum number of units of length, where units of length varies depending on the type that is being derived from. */
+    maxLength: string;
+    /** minExclusive is the exclusive lower bound of the value space for a datatype with the ordered property. The value of minExclusive must be in the value space of the base type or be equal to {value} in {base type definition}. */
+    minExclusive: string;
+    /** minInclusive is the inclusive lower bound of the value space for a datatype with the ordered property. The value of minInclusive must be in the value space of the base type. */
+    minInclusive: string;
+    /** maxLength is the maximum number of units of length, where units of length varies depending on the type that is being derived from. */
+    minLength: string;
     /** negativeInteger is ·derived· from nonPositiveInteger by setting the value of ·maxInclusive· to be -1.  This results in the standard mathematical concept of the negative integers.  The ·value space· of negativeInteger is the infinite set {...,-2,-1}.  The ·base type· of negativeInteger is nonPositiveInteger. */
     negativeInteger: string;
+    /** nonNegativeInteger is ·derived· from integer by setting the value of ·minInclusive· to be 0. This results in the standard mathematical concept of the non-negative integers. The ·value space· of nonNegativeInteger is the infinite set {0,1,2,...}. The ·base type· of nonNegativeInteger is integer. */
     nonNegativeInteger: string;
     /** nonPositiveInteger is ·derived· from integer by setting the value of ·maxInclusive· to be 0.  This results in the standard mathematical concept of the non-positive integers. The ·value space· of nonPositiveInteger is the infinite set {...,-2,-1,0}.  The ·base type· of nonPositiveInteger is integer. */
     nonPositiveInteger: string;
+    /** The set of strings that do not contain the carriage return (#xD), line feed (#xA) nor tab (#x9) characters. */
+    normalizedString: string;
+    /** pattern is a constraint on the value space of a datatype which is achieved by constraining the lexical space to literals which match a specific pattern. The value of pattern must be a regular expression. */
+    pattern: string;
     /** nonNegativeInteger is ·derived· from integer by setting the value of ·minInclusive· to be 0.  This results in the standard mathematical concept of the non-negative integers. The ·value space· of nonNegativeInteger is the infinite set {0,1,2,...}.  The ·base type· of nonNegativeInteger is integer. */
     positiveInteger: string;
     /** short is ·derived· from int by setting the value of ·maxInclusive· to be 32767 and ·minInclusive· to be -32768.  The ·base type· of short is int. */
@@ -41,21 +87,41 @@ export declare const XSD: {
     string: string;
     /** time represents instants of time that recur at the same point in each calendar day, or that occur in some arbitrary calendar day. */
     time: string;
+    /** The set of strings that do not contain the carriage return (#xD), line feed (#xA) nor tab (#x9) characters, that have no leading or trailing spaces (#x20) and that have no internal sequences of two or more spaces. */
+    token: string;
+    /** totalDigits controls the maximum number of values in the value space of datatypes derived from decimal, by restricting it to numbers that are expressible as i x 10^-n where i and n are integers such that |i| < 10^totalDigits and 0 <= n <= totalDigits. */
+    totalDigits: string;
+    /** unsignedByte is ·derived· from unsignedShort by setting the value of ·maxInclusive· to be 255.  The ·base type· of unsignedByte is unsignedShort. */
+    unsignedByte: string;
     /** unsignedInt is ·derived· from unsignedLong by setting the value of ·maxInclusive· to be 4294967295.  The ·base type· of unsignedInt is unsignedLong. */
     unsignedInt: string;
+    /** unsignedLong is ·derived· from nonNegativeInteger by setting the value of ·maxInclusive· to be 18446744073709551615.  The ·base type· of unsignedLong is nonNegativeInteger. */
+    unsignedLong: string;
     /** unsignedShort is ·derived· from unsignedInt by setting the value of ·maxInclusive· to be 65535.  The ·base type· of unsignedShort is unsignedInt. */
     unsignedShort: string;
-    /** unsignedLong is ·derived· from nonNegativeInteger by setting the value of ·maxInclusive· to be 18446744073709551615.  The ·base type· of unsignedLong is nonNegativeInteger. */
-    unsingedLong: string;
-    /** unsignedByte is ·derived· from unsignedShort by setting the value of ·maxInclusive· to be 255.  The ·base type· of unsignedByte is unsignedShort. */
-    usignedByte: string;
+    /** A string that describes whitespace normalization for a string type. */
+    whiteSpace: string;
 };
 /** Namespace URI of the xsd vocabulary. */
 export declare const _xsd: NamedNode;
 export declare const xsd: {
-    /** anyURI represents an Internationalized Resource Identifier Reference (IRI).  An anyURI value can be absolute or relative, and may have an optional fragment identifier (i.e., it may be an IRI Reference).  This type should be used when the value fulfills the role of an IRI, as defined in [RFC 3987] or its successor(s) in the IETF Standards Track. */
+    /** ENTITY represents the ENTITY attribute type from [XML].  The ·value space· of ENTITY is the set of all strings that ·match· the NCName production in [Namespaces in XML] and have been declared as an unparsed entity in a document type definition. The ·lexical space· of ENTITY is the set of all strings that ·match· the NCName production in [Namespaces in XML]. The ·base type· of ENTITY is NCName.  */
+    ENTITY: NamedNode;
+    /** ID represents the ID attribute type from [XML].  The ·value space· of ID is the set of all strings that ·match· the NCName production in [Namespaces in XML].  The ·lexical space· of ID is the set of all strings that ·match· the NCName production in [Namespaces in XML]. The ·base type· of ID is NCName. */
+    ID: NamedNode;
+    /**  IDREF represents the IDREF attribute type from [XML]. The ·value space· of IDREF is the set of all strings that ·match· the NCName production in [Namespaces in XML].  The ·lexical space· of IDREF is the set of strings that ·match· the NCName production in [Namespaces in XML]. The ·base type· of IDREF is NCName. */
+    IDREF: NamedNode;
+    NCName: NamedNode;
+    /** NMTOKEN represents the NMTOKEN attribute type from [XML]. The ·value space· of NMTOKEN is the set of tokens that ·match· the Nmtoken production in [XML]. The ·lexical space· of NMTOKEN is the set of strings that ·match· the Nmtoken production in [XML]. The ·base type· of NMTOKEN is token. */
+    NMTOKEN: NamedNode;
+    Name: NamedNode;
+    /** QName represents XML qualified names. The ·value space· of QName is the set of tuples {namespace name, local part}, where namespace name is an anyURI and local part is an NCName. The ·lexical space· of QName is the set of strings that ·match· the QName production of [Namespaces in XML]. */
+    QName: NamedNode;
+    /** The base class of any primitive XSD dataype. */
+    anySimpleType: NamedNode;
+    /** anyURI represents an Internationalized Resource Identifier Reference (IRI). An anyURI value can be absolute or relative, and may have an optional fragment identifier (i.e., it may be an IRI Reference).  This type should be used when the value fulfills the role of an IRI, as defined in [RFC 3987] or its successor(s) in the IETF Standards Track. */
     anyURI: NamedNode;
-    /** base64Binary represents arbitrary Base64-encoded binary data.  For base64Binary data the entire binary stream is encoded using the Base64 Encoding defined in [RFC 3548], which is derived from the encoding described in [RFC 2045]. */
+    /** base64Binary represents arbitrary Base64-encoded binary data. For base64Binary data the entire binary stream is encoded using the Base64 Encoding defined in [RFC 3548], which is derived from the encoding described in [RFC 2045]. */
     base64Binary: NamedNode;
     /** boolean represents the values of two-valued logic. */
     boolean: NamedNode;
@@ -65,6 +131,8 @@ export declare const xsd: {
     date: NamedNode;
     /** dateTime represents instants of time, optionally marked with a particular time zone offset.  Values representing the same instant but having different time zone offsets are equal but not identical. */
     dateTime: NamedNode;
+    /** The dateTimeStamp datatype is ·derived· from dateTime by giving the value required to its explicitTimezone facet. The result is that all values of dateTimeStamp are required to have explicit time zone offsets and the datatype is totally ordered. */
+    dateTimeStamp: NamedNode;
     /** decimal represents a subset of the real numbers, which can be represented by decimal numerals. The ·value space· of decimal is the set of numbers that can be obtained by dividing an integer by a non-negative power of ten, i.e., expressible as i / 10n where i and n are integers and n ≥ 0. Precision is not reflected in this value space; the number 2.0 is not distinct from the number 2.00. The order relation on decimal is the order relation on real numbers, restricted to this subset. */
     decimal: NamedNode;
     /** The double datatype is patterned after the IEEE double-precision 64-bit floating point datatype [IEEE 754-2008].  Each floating point datatype has a value space that is a subset of the rational numbers.  Floating point numbers are often used to approximate arbitrary real numbers. */
@@ -73,17 +141,47 @@ export declare const xsd: {
     duration: NamedNode;
     /** The float datatype is patterned after the IEEE single-precision 32-bit floating point datatype [IEEE 754-2008].  Its value space is a subset of the rational numbers.  Floating point numbers are often used to approximate arbitrary real numbers. */
     float: NamedNode;
+    /** fractionDigits controls the size of the minimum difference between values in the value space of datatypes derived from decimal, by restricting the value space to numbers that are expressible as i x 10^-n where i and n are integers and 0 <= n <= fractionDigits. */
+    fractionDigits: NamedNode;
+    gDay: NamedNode;
+    gMonth: NamedNode;
+    gMonthDay: NamedNode;
+    gYear: NamedNode;
+    gYearMonth: NamedNode;
+    /** Hex-encoded arbitrary binary data. */
+    hexBinary: NamedNode;
     /** int is ·derived· from long by setting the value of ·maxInclusive· to be 2147483647 and ·minInclusive· to be -2147483648.  The ·base type· of int is long. */
     int: NamedNode;
     /** integer is ·derived· from decimal by fixing the value of ·fractionDigits· to be 0 and disallowing the trailing decimal point.  This results in the standard mathematical concept of the integer numbers.  The ·value space· of integer is the infinite set {...,-2,-1,0,1,2,...}.  The ·base type· of integer is decimal. */
     integer: NamedNode;
+    /** llanguage represents natural language identifiers as defined by by [RFC 3066] . The ·value space· of language is the set of all strings that are valid language identifiers as defined [RFC 3066] . The ·lexical space· of language is the set of all strings that conform to the pattern [a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})* . The ·base type· of language is token. */
+    language: NamedNode;
+    /** length is the number of units of length, where units of length varies depending on the type that is being derived from. */
+    length: NamedNode;
     /** long is ·derived· from integer by setting the value of ·maxInclusive· to be 9223372036854775807 and ·minInclusive· to be -9223372036854775808. The ·base type· of long is integer. */
     long: NamedNode;
+    /** maxExclusive is the exclusive upper bound of the value space for a datatype with the ordered property. The value of maxExclusive must be in the value space of the base type or be equal to {value} in {base type definition}. */
+    maxExclusive: NamedNode;
+    /** maxInclusive is the inclusive upper bound of the value space for a datatype with the ordered property. The value of maxInclusive must be in the value space of the base type. */
+    maxInclusive: NamedNode;
+    /** minLength is the minimum number of units of length, where units of length varies depending on the type that is being derived from. */
+    maxLength: NamedNode;
+    /** minExclusive is the exclusive lower bound of the value space for a datatype with the ordered property. The value of minExclusive must be in the value space of the base type or be equal to {value} in {base type definition}. */
+    minExclusive: NamedNode;
+    /** minInclusive is the inclusive lower bound of the value space for a datatype with the ordered property. The value of minInclusive must be in the value space of the base type. */
+    minInclusive: NamedNode;
+    /** maxLength is the maximum number of units of length, where units of length varies depending on the type that is being derived from. */
+    minLength: NamedNode;
     /** negativeInteger is ·derived· from nonPositiveInteger by setting the value of ·maxInclusive· to be -1.  This results in the standard mathematical concept of the negative integers.  The ·value space· of negativeInteger is the infinite set {...,-2,-1}.  The ·base type· of negativeInteger is nonPositiveInteger. */
     negativeInteger: NamedNode;
+    /** nonNegativeInteger is ·derived· from integer by setting the value of ·minInclusive· to be 0. This results in the standard mathematical concept of the non-negative integers. The ·value space· of nonNegativeInteger is the infinite set {0,1,2,...}. The ·base type· of nonNegativeInteger is integer. */
     nonNegativeInteger: NamedNode;
     /** nonPositiveInteger is ·derived· from integer by setting the value of ·maxInclusive· to be 0.  This results in the standard mathematical concept of the non-positive integers. The ·value space· of nonPositiveInteger is the infinite set {...,-2,-1,0}.  The ·base type· of nonPositiveInteger is integer. */
     nonPositiveInteger: NamedNode;
+    /** The set of strings that do not contain the carriage return (#xD), line feed (#xA) nor tab (#x9) characters. */
+    normalizedString: NamedNode;
+    /** pattern is a constraint on the value space of a datatype which is achieved by constraining the lexical space to literals which match a specific pattern. The value of pattern must be a regular expression. */
+    pattern: NamedNode;
     /** nonNegativeInteger is ·derived· from integer by setting the value of ·minInclusive· to be 0.  This results in the standard mathematical concept of the non-negative integers. The ·value space· of nonNegativeInteger is the infinite set {0,1,2,...}.  The ·base type· of nonNegativeInteger is integer. */
     positiveInteger: NamedNode;
     /** short is ·derived· from int by setting the value of ·maxInclusive· to be 32767 and ·minInclusive· to be -32768.  The ·base type· of short is int. */
@@ -92,12 +190,18 @@ export declare const xsd: {
     string: NamedNode;
     /** time represents instants of time that recur at the same point in each calendar day, or that occur in some arbitrary calendar day. */
     time: NamedNode;
+    /** The set of strings that do not contain the carriage return (#xD), line feed (#xA) nor tab (#x9) characters, that have no leading or trailing spaces (#x20) and that have no internal sequences of two or more spaces. */
+    token: NamedNode;
+    /** totalDigits controls the maximum number of values in the value space of datatypes derived from decimal, by restricting it to numbers that are expressible as i x 10^-n where i and n are integers such that |i| < 10^totalDigits and 0 <= n <= totalDigits. */
+    totalDigits: NamedNode;
+    /** unsignedByte is ·derived· from unsignedShort by setting the value of ·maxInclusive· to be 255.  The ·base type· of unsignedByte is unsignedShort. */
+    unsignedByte: NamedNode;
     /** unsignedInt is ·derived· from unsignedLong by setting the value of ·maxInclusive· to be 4294967295.  The ·base type· of unsignedInt is unsignedLong. */
     unsignedInt: NamedNode;
+    /** unsignedLong is ·derived· from nonNegativeInteger by setting the value of ·maxInclusive· to be 18446744073709551615.  The ·base type· of unsignedLong is nonNegativeInteger. */
+    unsignedLong: NamedNode;
     /** unsignedShort is ·derived· from unsignedInt by setting the value of ·maxInclusive· to be 65535.  The ·base type· of unsignedShort is unsignedInt. */
     unsignedShort: NamedNode;
-    /** unsignedLong is ·derived· from nonNegativeInteger by setting the value of ·maxInclusive· to be 18446744073709551615.  The ·base type· of unsignedLong is nonNegativeInteger. */
-    unsingedLong: NamedNode;
-    /** unsignedByte is ·derived· from unsignedShort by setting the value of ·maxInclusive· to be 255.  The ·base type· of unsignedByte is unsignedShort. */
-    usignedByte: NamedNode;
+    /** A string that describes whitespace normalization for a string type. */
+    whiteSpace: NamedNode;
 };

package/dist/rdf/dataset-view.d.ts

@@ -26,9 +26,10 @@ export interface DatasetViewOptions {
      */
     object?: rdfjs.Term | null;
     /**
-     * Whether to include inferred triples from the inference graphs associated with the scoped
-     * graphs. If undefined, inferred triples are included when a reasoner is available. If `true`
-     * without a reasoner, an error is thrown. Only applies when the view is scoped to graphs.
+     * Whether to include inferred triples. If undefined, inferred triples are included when a
+     * reasoner is available. With graphs, `false` leaves their inference graphs out; without
+     * graphs, the view spans every graph of the store and `false` leaves every inference graph
+     * out. If `true` without a reasoner, an error is thrown.
      */
     includeInferred?: boolean;
 }
@@ -48,6 +49,10 @@ export declare class DatasetView implements rdfjs.DatasetCore<rdfjs.Quad> {
      * `undefined` means the view spans all graphs; an empty array means the view is provably empty.
      */
     private readonly _scope?;
+    /**
+     * Whether the quads of the inference graphs are left out of a view that spans all graphs.
+     */
+    private readonly _excludeInferred;
     private _cachedSize?;
     private _cachedSizeVersion;
     constructor(store: Store, options?: DatasetViewOptions);
@@ -57,6 +62,10 @@ export declare class DatasetView implements rdfjs.DatasetCore<rdfjs.Quad> {
      * until the store is modified.
      */
     get size(): number;
+    /**
+     * Count the quads of the view's pattern in the inference graphs of the store.
+     */
+    private _countInferred;
     /**
      * Not supported: the view is read-only.
      * @throws An error indicating that the view is read-only.

package/dist/rdf/reasoners/reasoner.d.ts

@@ -8,6 +8,12 @@ export interface GraphUriGenerator {
      * @param uri A URI.
      */
     getGraphUri(uri: string | rdfjs.Quad_Graph): string;
+    /**
+     * Check if a given URI is the URI of an inference graph generated by this handler.
+     * @param uri A URI.
+     * @returns `true` if the URI is an inference graph URI, `false` otherwise.
+     */
+    isInferenceGraphUri(uri: string | rdfjs.Quad_Graph): boolean;
 }
 /**
  * Default implementation of the InferenceGraphHandler interface. It generates URIs

package/dist/rdf/store.d.ts

@@ -180,6 +180,20 @@ export declare class Store implements rdfjs.DatasetCore<rdfjs.Quad> {
      * @returns `true` if the store contains triples in the graph URI, `false` otherwise.
      */
     hasGraph(graphUri: rdfjs.Quad_Graph | string): boolean;
+    /**
+     * Indicates whether a graph holds the triples the reasoner inferred from another graph.
+     * @param graph A graph term or URI.
+     * @returns `true` if the graph is an inference graph of the reasoner of this store, `false` otherwise or without a reasoner.
+     */
+    isInferenceGraph(graph: rdfjs.Quad_Graph | string): boolean;
+    /**
+     * Indicates whether a quad was inferred by the reasoner, i.e. whether it is stored in an inference
+     * graph. A triple that is asserted and inferred exists as two quads; only the quad in the inference
+     * graph is inferred.
+     * @param quad A quad.
+     * @returns `true` if the quad is stored in an inference graph, `false` otherwise.
+     */
+    isInferred(quad: rdfjs.Quad): boolean;
     /**
      * Apply inference to the given graph and store the triples in the associated inference graph.
      * @param graphUri A graph URI.
@@ -223,10 +237,11 @@ export declare class Store implements rdfjs.DatasetCore<rdfjs.Quad> {
     countQuads(subject?: rdfjs.Term | null, predicate?: rdfjs.Term | null, object?: rdfjs.Term | null, graph?: rdfjs.Term | null): number;
     /**
      * Returns a lazy, read-only dataset view of the quads matching the given pattern.
-     * Implements the RDF/JS `DatasetCore.match` semantics: the result reflects the
-     * current contents of the store and does not copy any quads. Because the view
-     * iterates the live indexes, do not add or delete quads while iterating it;
-     * take a snapshot with `Array.from(...)` first.
+     * Implements the RDF/JS `DatasetCore.match` semantics: a graph names exactly that
+     * graph and no graph means every graph of the store, inference graphs included.
+     * The result reflects the current contents of the store and does not copy any
+     * quads. Because the view iterates the live indexes, do not add or delete quads
+     * while iterating it; take a snapshot with `Array.from(...)` first.
      * @param subject The optional subject.
      * @param predicate The optional predicate.
      * @param object The optional object.
@@ -257,6 +272,10 @@ export declare class Store implements rdfjs.DatasetCore<rdfjs.Quad> {
      * @param subject A subject URI or null to match any subject.
      * @param predicate A predicate URI or null to match any predicate.
      * @param object An object URI or null to match any object.
+     * @param includeInferred Whether to read the inference graphs. With graphs given, `undefined` and
+     *  `true` add the inference graph of each graph when a reasoner is available and `false` reads only
+     *  the given graphs. Without graphs, `undefined` and `true` read every graph of the store and `false`
+     *  reads every graph except the inference graphs. `true` without a reasoner throws.
      */
     matchAll(graphUris: string | string[] | undefined, subject: rdfjs.Quad_Subject | null, predicate: rdfjs.Quad_Predicate | null, object: rdfjs.Quad_Object | null, includeInferred?: boolean): Generator<rdfjs.Quad, void, any>;
     /**
@@ -273,9 +292,11 @@ export declare class Store implements rdfjs.DatasetCore<rdfjs.Quad> {
      * The view is lazy and live: it reflects the current contents of the store without
      * copying any quads. If you need an immutable snapshot, copy the view into a new
      * dataset, e.g. `RdfStore.createDefault().asDataset()`.
-     * @param graphUris Optional graph URI or array of graph URIs. If undefined, all quads are included.
+     * @param graphUris Optional graph URI or array of graph URIs. If undefined, all graphs are included.
      * @param includeInferred Whether to include inferred triples. If undefined, inferred triples
-     *  are included when a reasoner is available. If `true` without a reasoner, an error is thrown.
+     *  are included when a reasoner is available. If `false`, the inference graphs of the given
+     *  graphs are left out, or, without graphs, every inference graph of the store. If `true`
+     *  without a reasoner, an error is thrown.
      * @returns A read-only dataset view of the matching quads.
      */
     getDataset(graphUris?: string | string[], includeInferred?: boolean): DatasetView;

package/package.json

@@ -10,7 +10,7 @@
     "ontology",
     "vocabulary"
   ],
-  "version": "2.3.0",
+  "version": "2.5.0",
   "private": false,
   "author": {
     "name": "Sebastian Faubel"
@@ -54,7 +54,7 @@
     "serve:docs": "npx --yes serve docs"
   },
   "devDependencies": {
-    "@faubulous/mentor-cli": "^0.2.1",
+    "@faubulous/mentor-cli": "^0.2.3",
     "@types/node": "^26.6.5",
     "@vitest/coverage-v8": "^5.0.5",
     "esbuild": "^0.28.2",