@tpluscode/rdf-ns-builders 3.0.3 → 4.0.0

package/vocabularies/list.d.ts

@@ -0,0 +1,32 @@
+import { NamedNode } from "@rdfjs/types";
+interface List {
+    '': NamedNode<'http://www.w3.org/2000/10/swap/list#'>;
+    /**
+     * Iff the subject is a list of lists and the concatenation of all those lists
+     * is the object, then this is true.
+     * eg  ( (1 2) (3 4) ) list:append (1 2 3 4).
+     * The object can be calculated as a function of the subject.
+     *
+     */
+    "append": NamedNode<'http://www.w3.org/2000/10/swap/list#append'>;
+    /**
+     * Iff the object is a list and the subject is in that list, then this is true.
+     *
+     */
+    "in": NamedNode<'http://www.w3.org/2000/10/swap/list#in'>;
+    /**
+     * Iff the suject is a list and the obbject is the last thing that list, then this is true.
+     * The object can be calculated as a function of the list.
+     *
+     */
+    "last": NamedNode<'http://www.w3.org/2000/10/swap/list#last'>;
+    /**
+     * Iff the subject is a list and the obbject is in that list, then this is true.
+     *
+     */
+    "member": NamedNode<'http://www.w3.org/2000/10/swap/list#member'>;
+}
+export declare const strict: Record<keyof List, NamedNode<string>> & ((property?: TemplateStringsArray | keyof List | undefined) => NamedNode<string>) & List;
+export declare const loose: Record<any, NamedNode<string>> & ((property?: any) => NamedNode<string>) & List;
+export {};
+//# sourceMappingURL=list.d.ts.map

package/vocabularies/list.js

@@ -0,0 +1,4 @@
+import namespace from "@rdfjs/namespace";
+const builder = namespace("http://www.w3.org/2000/10/swap/list#");
+export const strict = builder;
+export const loose = builder;

package/vocabularies/log.d.ts

@@ -0,0 +1,225 @@
+import { NamedNode } from "@rdfjs/types";
+interface Log {
+    '': NamedNode<'http://www.w3.org/2000/10/swap/log#'>;
+    /**
+     * Any statement mentioning anything in this class
+     * is considered boring and purged by the cwm --purge option.
+     * This is a convenience, and does not have any value when published as a
+     * general fact on the web.
+     */
+    "Chaff": NamedNode<'http://www.w3.org/2000/10/swap/log#Chaff'>;
+    "Formula": NamedNode<'http://www.w3.org/2000/10/swap/log#Formula'>;
+    "List": NamedNode<'http://www.w3.org/2000/10/swap/log#List'>;
+    /**
+     * A document which, which parsed as Notation3
+     * as defined in general by http://www.w3.org/DesignIssues/Notation3.html
+     * and this schema, conveys the intent of the author by the semantics defined
+     * on those specifications, and the semantics defined by the specifications
+     * of any other identifiers used in the document.
+     *
+     */
+    "N3Document": NamedNode<'http://www.w3.org/2000/10/swap/log#N3Document'>;
+    "Other": NamedNode<'http://www.w3.org/2000/10/swap/log#Other'>;
+    "String": NamedNode<'http://www.w3.org/2000/10/swap/log#String'>;
+    /**
+     * Something which is true: believe it as you would believe this.
+     *
+     * 	Understood natively by cwm in that it will execute rules in a formula
+     * 	declared a Truth within a formula it is already taking rules from.
+     */
+    "Truth": NamedNode<'http://www.w3.org/2000/10/swap/log#Truth'>;
+    /**
+     * All possible conclusions which can be drawn from a formula.
+     *
+     * The object of this function, a formula, is the set of conclusions which can be
+     * drawn from the subject formula, by successively applying any
+     * rules it contains to the data it contains. This is equivalent to
+     * cwm's "--think" command line function.  It does use built-ins, so
+     * it may for example indirectly invoke other documents, validate
+     * signatures, etc.
+     *
+     */
+    "conclusion": NamedNode<'http://www.w3.org/2000/10/swap/log#conclusion'>;
+    /**
+     * "A function to merge formulae: logical AND.
+     *
+     * The subject is a list of formulae.
+     * The object, which can be generated, is a formula containing a copy
+     * of each of the formulae in the list on the left.
+     * A cwm built-in function.
+     *
+     */
+    "conjunction": NamedNode<'http://www.w3.org/2000/10/swap/log#conjunction'>;
+    /**
+     * This connects a document and a string that represents it.
+     * (Cwm knows how to go get a document in order to evaluate this.)
+     * Note that the content-type of the information is not given and
+     * so must be known or guessed.
+     */
+    "content": NamedNode<'http://www.w3.org/2000/10/swap/log#content'>;
+    /**
+     * 	When document D is the definitiveDocument for property P,
+     * any statement X P Y is true iff and only if the semantics of document D
+     * include that statement.
+     *
+     * For example, there may be a definitive document for the zipcode of
+     * airports by airport code, and so on. This is useful to let a reasoner
+     * know that it can extend its query to the given document.
+     * (Cwm will do this if its mode includes "r").
+     *
+     */
+    "definitiveDocument": NamedNode<'http://www.w3.org/2000/10/swap/log#definitiveDocument'>;
+    /**
+     * 	When service S is the definitiveService for property P,
+     * any statement X P Y is true iff and only if a query to S returns
+     * that it is.  The protocol for the service S depends on the scheme.
+     * For mysql protocol, the URI of the service is like
+     * sql://user:password@host.domain/database/.
+     *
+     * For example, there may be a definitive service for the zipcode of
+     * airports by airport code, and so on. This is useful to let a reasoner
+     * know that it can help resolve a query by delegating it to the service
+     * in question.
+     * (Cwm will do this if its mode includes "r").
+     *
+     */
+    "definitiveService": NamedNode<'http://www.w3.org/2000/10/swap/log#definitiveService'>;
+    /**
+     * Takes a list of a string and a URI and creates a datatyped
+     *      literal. For example, { ("2005-03-30T11:00:00" :tz) log:dtlit ?X } => { ?X a :Answer } .
+     *     will produce "2005-03-30T11:00:00"^^:tz a :Answer .
+     */
+    "dtlit": NamedNode<'http://www.w3.org/2000/10/swap/log#dtlit'>;
+    /**
+     * True if the subject and object are the same RDF node (symbol or literal).
+     * Do not confuse with owl:sameAs.
+     * A cwm built-in logical operator, RDF graph level.
+     *
+     */
+    "equalTo": NamedNode<'http://www.w3.org/2000/10/swap/log#equalTo'>;
+    /**
+     * Logical implication.
+     * This is the relation between the antecedent (subject) and
+     * conclusion (object) of a rule.
+     * The application of a rule to a knowledge-base is as follows.
+     * For every substitution which, applied to the antecedent,
+     * gives a formula which is a subset of the knowledge-base,
+     * then the result of applying that same substitution to the
+     * conclusion may be added to the knowledge-base.
+     *
+     * related: See log:conclusion.
+     * (See the CWM manual for command line options to determine how
+     * rules from different sources are applied to and the results
+     * added to various formula.)
+     *
+     */
+    "implies": NamedNode<'http://www.w3.org/2000/10/swap/log#implies'>;
+    /**
+     * The subject formula includes the object formula.
+     * Formula A includes formula B if there exists some substitution
+     * which when applied to B creates a formula B' such that for
+     * every statement in B' is also in A, every variable
+     * universally (or existentially) quantified in B' is quantified in
+     * the same way in A.
+     *
+     * Variable substitution is applied recursively to nested compound terms such as
+     * formulae, lists and sets.
+     *
+     * (Understood natively by cwm when in in the antecedent of a rule.
+     * You can use this to peer inside nested formulae.)
+     */
+    "includes": NamedNode<'http://www.w3.org/2000/10/swap/log#includes'>;
+    /** The subject formula, expressed as N3, gives this string. */
+    "n3String": NamedNode<'http://www.w3.org/2000/10/swap/log#n3String'>;
+    /**
+     * Equality in this sense is actually the same URI.
+     * A cwm built-in logical operator.
+     *
+     */
+    "notEqualTo": NamedNode<'http://www.w3.org/2000/10/swap/log#notEqualTo'>;
+    /**
+     * The object formula is NOT a subset of subject.
+     *     True iff log:includes is false.
+     *     The converse of log:includes. (Understood natively by cwm.
+     *     The subject formula may contain variables.
+     *     (In cwm, variables must of course end up getting bound
+     *     before the log:include test can be done, or an infinite result set
+     *     would result)
+     *     Related: See includes
+     */
+    "notIncludes": NamedNode<'http://www.w3.org/2000/10/swap/log#notIncludes'>;
+    /**
+     * The subject is a key and the object is a string,
+     * where the strings are to be output in the order of the keys.
+     * See cwm --strings in cwm --help.
+     *
+     */
+    "outputString": NamedNode<'http://www.w3.org/2000/10/swap/log#outputString'>;
+    /** The subject string, parsed as N3, gives this formula. */
+    "parsedAsN3": NamedNode<'http://www.w3.org/2000/10/swap/log#parsedAsN3'>;
+    /**
+     * For anything identified by a URI with a fragid, this is the
+     * thing identified by the same URI without a hash or fragid.
+     * For anything else, it is itself.
+     */
+    "racine": NamedNode<'http://www.w3.org/2000/10/swap/log#racine'>;
+    /**
+     * This is a low-level language type, one of log:Formula, log:Literal,
+     * log:List, log:Set or log:Other.
+     * Example: log:semanticsOrError returns either a formula or a string,
+     * and you can check which using log:rawType.
+     *
+     */
+    "rawType": NamedNode<'http://www.w3.org/2000/10/swap/log#rawType'>;
+    /**
+     * This allows one to look at the actual string of the URI which identifies this,
+     * for anything, even a blank node or a formula. This peeks into the internal
+     * workings of cwm, and so is not normally used. Use log:uri instead.
+     *
+     */
+    "rawUri": NamedNode<'http://www.w3.org/2000/10/swap/log#rawUri'>;
+    /**
+     * The log:semantics of a document is the formula.
+     * achieved by parsing representation of the document.
+     *  For a document in Notation3, log:semantics is the
+     * log:parsedAsN3 of the log:contents of the document.
+     * For a document in RDF/XML, it is parsed according to the
+     * RDF/XML specification to yield an RDF formula
+     * (a subclass of N3 log:Formula).
+     *
+     * [Aside: Philosophers will be distracted here into worrying about the meaning
+     * of meaning. At least we didn't call this function "meaning"!
+     * In as much as N3 is used as an interlingua for interoperability
+     * for different systems, this for an N3 based system is the meaning
+     * expressed by a document.]
+     *
+     * (Cwm knows how to go get a document and parse N3 and RDF/XML
+     * it in order to evaluate this.
+     * Other languages for web documents
+     * may be defined whose N3 semantics are therefore
+     * also calculable, and so they could be added in due course.
+     * See for example GRDDL, RDFa, etc)
+     */
+    "semantics": NamedNode<'http://www.w3.org/2000/10/swap/log#semantics'>;
+    /**
+     * This connects a document and either the formula it parses to,
+     * or an error message explaining what went wrong with trying. See log:semantics.
+     * (Cwm knows how to go get a document and parse it in order to evaluate this.)
+     *
+     */
+    "semanticsOrError": NamedNode<'http://www.w3.org/2000/10/swap/log#semanticsOrError'>;
+    /**
+     * This allows one to look at the actual string of the URI which identifies this.
+     *
+     * (Cwm can get the URI of a resource or get the resource from the URI.)
+     * This is a level breaker, breaking the rule of not looking inside a
+     * URI.   Use (eg with  string:match) to replace RDF's old "aboutEach"
+     * functionality. Use to implement the URI spec and protocol specs, etc.
+     *
+     */
+    "uri": NamedNode<'http://www.w3.org/2000/10/swap/log#uri'>;
+}
+export declare const strict: Record<keyof Log, NamedNode<string>> & ((property?: TemplateStringsArray | keyof Log | undefined) => NamedNode<string>) & Log;
+export declare const loose: Record<any, NamedNode<string>> & ((property?: any) => NamedNode<string>) & Log;
+export {};
+//# sourceMappingURL=log.d.ts.map

package/vocabularies/log.js

@@ -0,0 +1,4 @@
+import namespace from "@rdfjs/namespace";
+const builder = namespace("http://www.w3.org/2000/10/swap/log#");
+export const strict = builder;
+export const loose = builder;

package/vocabularies/m4i.d.ts

@@ -0,0 +1,71 @@
+import { NamedNode } from "@rdfjs/types";
+interface M4i {
+    '': NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#'>;
+    "ProcessingStep": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#ProcessingStep'>;
+    "ContactPerson": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#ContactPerson'>;
+    "DataCollector": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#DataCollector'>;
+    "DataCurator": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#DataCurator'>;
+    "DataManager": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#DataManager'>;
+    "Distributor": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#Distributor'>;
+    "Editor": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#Editor'>;
+    "HostingInstitution": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#HostingInstitution'>;
+    "KindOfQuantity": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#KindOfQuantity'>;
+    "Method": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#Method'>;
+    "NumericalAssignment": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#NumericalAssignment'>;
+    "Other": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#Other'>;
+    "Producer": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#Producer'>;
+    "ProjectLeader": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#ProjectLeader'>;
+    "ProjectManager": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#ProjectManager'>;
+    "ProjectMember": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#ProjectMember'>;
+    "RegistrationAgency": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#RegistrationAgency'>;
+    "RegistrationAuthority": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#RegistrationAuthority'>;
+    "RelatedPerson": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#RelatedPerson'>;
+    "ResearchGroup": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#ResearchGroup'>;
+    "Researcher": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#Researcher'>;
+    "RightsHolder": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#RightsHolder'>;
+    "Sponsor": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#Sponsor'>;
+    "Supervisor": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#Supervisor'>;
+    "Tool": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#Tool'>;
+    "UncertaintyDeclaration": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#UncertaintyDeclaration'>;
+    "UsageInstruction": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#UsageInstruction'>;
+    "WorkPackageLeader": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#WorkPackageLeader'>;
+    "endOfProject": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#endOfProject'>;
+    "hasAdmissibleUnit": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#hasAdmissibleUnit'>;
+    "hasAdmissibleValue": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#hasAdmissibleValue'>;
+    "hasAssignedValue": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#hasAssignedValue'>;
+    "hasAssignmentTimestamp": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#hasAssignmentTimestamp'>;
+    "hasCoverageInterval": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#hasCoverageInterval'>;
+    "hasUncertaintyDeclaration": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#hasUncertaintyDeclaration'>;
+    "hasDateAssignmentCreated": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#hasDateAssignmentCreated'>;
+    "hasDateAssignmentDeleted": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#hasDateAssignmentDeleted'>;
+    "hasDateAssignmentModified": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#hasDateAssignmentModified'>;
+    "hasDateAssignmentValidFrom": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#hasDateAssignmentValidFrom'>;
+    "hasDateAssignmentValidUntil": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#hasDateAssignmentValidUntil'>;
+    "hasEmployedTool": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#hasEmployedTool'>;
+    "isEmployedToolIn": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#isEmployedToolIn'>;
+    "hasExpandedUnc": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#hasExpandedUnc'>;
+    "hasKindOfQuantity": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#hasKindOfQuantity'>;
+    "hasNumericalValue": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#hasNumericalValue'>;
+    "hasParameter": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#hasParameter'>;
+    "hasRorId": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#hasRorId'>;
+    "identifier": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#identifier'>;
+    "hasRuntimeAssignment": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#hasRuntimeAssignment'>;
+    "hasSymbol": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#hasSymbol'>;
+    "hasUnit": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#hasUnit'>;
+    "hasVariable": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#hasVariable'>;
+    "hasVariableDescription": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#hasVariableDescription'>;
+    "implementedByTool": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#implementedByTool'>;
+    "implementsMethod": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#implementsMethod'>;
+    "inProject": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#inProject'>;
+    "projectParticipant": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#projectParticipant'>;
+    "investigates": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#investigates'>;
+    "investigatesProperty": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#investigatesProperty'>;
+    "orcidId": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#orcidId'>;
+    "projectReferenceID": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#projectReferenceID'>;
+    "realizesMethod": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#realizesMethod'>;
+    "startOfProject": NamedNode<'http://w3id.org/nfdi4ing/metadata4ing#startOfProject'>;
+}
+export declare const strict: Record<keyof M4i, NamedNode<string>> & ((property?: TemplateStringsArray | keyof M4i | undefined) => NamedNode<string>) & M4i;
+export declare const loose: Record<any, NamedNode<string>> & ((property?: any) => NamedNode<string>) & M4i;
+export {};
+//# sourceMappingURL=m4i.d.ts.map

package/vocabularies/m4i.js

@@ -0,0 +1,4 @@
+import namespace from "@rdfjs/namespace";
+const builder = namespace("http://w3id.org/nfdi4ing/metadata4ing#");
+export const strict = builder;
+export const loose = builder;

package/vocabularies/math.d.ts

@@ -0,0 +1,106 @@
+import { NamedNode } from "@rdfjs/types";
+interface Math {
+    '': NamedNode<'http://www.w3.org/2000/10/swap/math#'>;
+    /** A math:Function is unique in terms of math:EqualTo. */
+    "Function": NamedNode<'http://www.w3.org/2000/10/swap/math#Function'>;
+    /**
+     * The class of things that are DAML lists were all of the
+     *       members are math:Value items.
+     */
+    "List": NamedNode<'http://www.w3.org/2000/10/swap/math#List'>;
+    /**
+     * a logical operator allows evaluation eihter way, or testing relationship
+     *          between two values
+     */
+    "LogicalOperator": NamedNode<'http://www.w3.org/2000/10/swap/math#LogicalOperator'>;
+    /** A math:ReverseFunction is unambiguous in terms of math:EqualTo. */
+    "ReverseFunction": NamedNode<'http://www.w3.org/2000/10/swap/math#ReverseFunction'>;
+    "StrictProperty": NamedNode<'http://www.w3.org/2000/10/swap/math#StrictProperty'>;
+    /** This is the class of things that are math lists with only two members. */
+    "TwoMemberedList": NamedNode<'http://www.w3.org/2000/10/swap/math#TwoMemberedList'>;
+    /** The class of things that are numeric float values as in Python. */
+    "Value": NamedNode<'http://www.w3.org/2000/10/swap/math#Value'>;
+    /** The object is calulated as the absolute value of the subject. */
+    "absoluteValue": NamedNode<'http://www.w3.org/2000/10/swap/math#absoluteValue'>;
+    /** The subject is a pair of numbers. The object is calulated as the arc tangent value of the ratio of the two subject values. */
+    "atan2": NamedNode<'http://www.w3.org/2000/10/swap/math#atan2'>;
+    /** The subject is an angle expressed in radians. The object is calulated as the cosine value of the subject. */
+    "cos": NamedNode<'http://www.w3.org/2000/10/swap/math#cos'>;
+    /** The subject is an angle expressed in radians. The object is calulated as the conversion in degrees of the value of the subject. */
+    "degrees": NamedNode<'http://www.w3.org/2000/10/swap/math#degrees'>;
+    /**
+     * The subject is a pair of numbers. The object
+     * is calculated by subtracting the second number of the pair from the first.
+     *
+     */
+    "difference": NamedNode<'http://www.w3.org/2000/10/swap/math#difference'>;
+    /** True iff the subject is a string representation of a number which  is EQUAL TO a number of which the object is a string representation. */
+    "equalTo": NamedNode<'http://www.w3.org/2000/10/swap/math#equalTo'>;
+    /**
+     * The subject is a pair of numbers. The object
+     * is calculated by raising the first number of the power of the second.
+     *
+     */
+    "exponentiation": NamedNode<'http://www.w3.org/2000/10/swap/math#exponentiation'>;
+    /** True iff the subject is a string representation of a number which  is greater than the number of which the object is a string representation. */
+    "greaterThan": NamedNode<'http://www.w3.org/2000/10/swap/math#greaterThan'>;
+    /**
+     * The subject is a pair of integer numbers. The object
+     * is calculated by dividing the first number of the pair by the second, ignoring remainder.
+     *
+     */
+    "integerQuotient": NamedNode<'http://www.w3.org/2000/10/swap/math#integerQuotient'>;
+    /** True iff the subject is a string representation of a number which  is LESS than a number of which the object is a string representation. */
+    "lessThan": NamedNode<'http://www.w3.org/2000/10/swap/math#lessThan'>;
+    /**
+     * The number of items in a list. The subject is a list,
+     * the object is calculated as the number of members.
+     */
+    "memberCount": NamedNode<'http://www.w3.org/2000/10/swap/math#memberCount'>;
+    /** The subject or object is calculated to be the negation of the other. */
+    "negation": NamedNode<'http://www.w3.org/2000/10/swap/math#negation'>;
+    /** True iff the subject is a string representation of a number which  is NOT EQUAL to a number of which the object is a string representation. */
+    "notEqualTo": NamedNode<'http://www.w3.org/2000/10/swap/math#notEqualTo'>;
+    /** True iff the subject is a string representation of a number which is NOT greater than the number of which the object is a string representation. */
+    "notGreaterThan": NamedNode<'http://www.w3.org/2000/10/swap/math#notGreaterThan'>;
+    /** True iff the subject is a string representation of a number which  is NOT LESS than a number of which the object is a string representation. */
+    "notLessThan": NamedNode<'http://www.w3.org/2000/10/swap/math#notLessThan'>;
+    /**
+     * The subject is a list of numbers.
+     * The object is calculated as the arithmentic product of those numbers.
+     *
+     */
+    "product": NamedNode<'http://www.w3.org/2000/10/swap/math#product'>;
+    /**
+     * The subject is a pair of numbers. The object
+     * is calculated by dividing the first number of the pair by the second.
+     *
+     */
+    "quotient": NamedNode<'http://www.w3.org/2000/10/swap/math#quotient'>;
+    /**
+     * The subject is a pair of integers. The object
+     * is calculated by dividing the first number of the pair by the second and taking the remainder.
+     *
+     */
+    "remainder": NamedNode<'http://www.w3.org/2000/10/swap/math#remainder'>;
+    /** The object is calulated as the subject rounded to the nearest integer. */
+    "rounded": NamedNode<'http://www.w3.org/2000/10/swap/math#rounded'>;
+    /** The subject is an angle expressed in radians. The object is calulated as the sine value of the subject. */
+    "sin": NamedNode<'http://www.w3.org/2000/10/swap/math#sin'>;
+    /** The subject is an angle expressed in radians. The object is calulated as the hyperbolic sine value of the subject. */
+    "sinh": NamedNode<'http://www.w3.org/2000/10/swap/math#sinh'>;
+    /**
+     * The subject is a list of numbers.
+     * The object is calculated as the arithmentic sum of those numbers.
+     *
+     */
+    "sum": NamedNode<'http://www.w3.org/2000/10/swap/math#sum'>;
+    /** The subject is an angle expressed in radians. The object is calulated as the tangent value of the subject. */
+    "tan": NamedNode<'http://www.w3.org/2000/10/swap/math#tan'>;
+    /** The subject is an angle expressed in radians. The object is calulated as the hyperbolic tangent value of the subject. */
+    "tanh": NamedNode<'http://www.w3.org/2000/10/swap/math#tanh'>;
+}
+export declare const strict: Record<keyof Math, NamedNode<string>> & ((property?: TemplateStringsArray | keyof Math | undefined) => NamedNode<string>) & Math;
+export declare const loose: Record<any, NamedNode<string>> & ((property?: any) => NamedNode<string>) & Math;
+export {};
+//# sourceMappingURL=math.d.ts.map

package/vocabularies/math.js

@@ -0,0 +1,4 @@
+import namespace from "@rdfjs/namespace";
+const builder = namespace("http://www.w3.org/2000/10/swap/math#");
+export const strict = builder;
+export const loose = builder;

package/vocabularies/oidc.d.ts

@@ -0,0 +1,36 @@
+import { NamedNode } from "@rdfjs/types";
+interface Oidc {
+    '': NamedNode<'http://www.w3.org/ns/solid/oidc#'>;
+    /** TODO */
+    "application_type": NamedNode<'http://www.w3.org/ns/solid/oidc#application_type'>;
+    /** A name for this client that can be presented to an End-User */
+    "client_name": NamedNode<'http://www.w3.org/ns/solid/oidc#client_name'>;
+    /** A URI for this client's home page */
+    "client_uri": NamedNode<'http://www.w3.org/ns/solid/oidc#client_uri'>;
+    /** A collection of URIs where individuals or entities responsible for this client can be contacted. */
+    "contacts": NamedNode<'http://www.w3.org/ns/solid/oidc#contacts'>;
+    /** TODO */
+    "default_max_age": NamedNode<'http://www.w3.org/ns/solid/oidc#default_max_age'>;
+    /** A collection of OAuth 2.0 Grant Types that the client will restrict itself to using. */
+    "grant_types": NamedNode<'http://www.w3.org/ns/solid/oidc#grant_types'>;
+    /** A URI for this client's logo */
+    "logo_uri": NamedNode<'http://www.w3.org/ns/solid/oidc#logo_uri'>;
+    /** A URI for this client's policy document */
+    "policy_uri": NamedNode<'http://www.w3.org/ns/solid/oidc#policy_uri'>;
+    /** A collection of registered URIs used by the client for redirection */
+    "redirect_uris": NamedNode<'http://www.w3.org/ns/solid/oidc#redirect_uris'>;
+    /** TODO */
+    "require_auth_time": NamedNode<'http://www.w3.org/ns/solid/oidc#require_auth_time'>;
+    /** A collection of OAuth 2.0 Response Types that the client will restrict itself to using. */
+    "response_types": NamedNode<'http://www.w3.org/ns/solid/oidc#response_types'>;
+    /** An OAuth2 scope for the requested access token. */
+    "scope": NamedNode<'http://www.w3.org/ns/solid/oidc#scope'>;
+    /** The requested client authentication method for the Token Endpoint */
+    "token_endpoint_auth_method": NamedNode<'http://www.w3.org/ns/solid/oidc#token_endpoint_auth_method'>;
+    /** A URI for this client's terms of service document */
+    "tos_uri": NamedNode<'http://www.w3.org/ns/solid/oidc#tos_uri'>;
+}
+export declare const strict: Record<keyof Oidc, NamedNode<string>> & ((property?: TemplateStringsArray | keyof Oidc | undefined) => NamedNode<string>) & Oidc;
+export declare const loose: Record<any, NamedNode<string>> & ((property?: any) => NamedNode<string>) & Oidc;
+export {};
+//# sourceMappingURL=oidc.d.ts.map

package/vocabularies/oidc.js

@@ -0,0 +1,4 @@
+import namespace from "@rdfjs/namespace";
+const builder = namespace("http://www.w3.org/ns/solid/oidc#");
+export const strict = builder;
+export const loose = builder;

package/vocabularies/pim.d.ts

@@ -0,0 +1,70 @@
+import { NamedNode } from "@rdfjs/types";
+interface Pim {
+    '': NamedNode<'http://www.w3.org/ns/pim/space#'>;
+    "ConfigurationFile": NamedNode<'http://www.w3.org/ns/pim/space#ConfigurationFile'>;
+    /**
+     * A  storage is a space of URIs in which you can individually control for each resource
+     *     who has access to it.
+     *
+     */
+    "ControlledStorage": NamedNode<'http://www.w3.org/ns/pim/space#ControlledStorage'>;
+    /**
+     * A storage is a space of URIs in which you have access to data.
+     *
+     */
+    "Storage": NamedNode<'http://www.w3.org/ns/pim/space#Storage'>;
+    /**
+     * This is a workspace for storing the
+     *     information about the other workspaces.
+     *     As a user, you normally don't have to worry about it.
+     */
+    "MasterWorkspace": NamedNode<'http://www.w3.org/ns/pim/space#MasterWorkspace'>;
+    /** Access only by the you, the user. */
+    "PrivateWorkspace": NamedNode<'http://www.w3.org/ns/pim/space#PrivateWorkspace'>;
+    /**
+     * A personal storage is a space of URIs in which you and only you have access to data,
+     *     you cannot give access to anyone else.
+     *
+     */
+    "PersonalStorage": NamedNode<'http://www.w3.org/ns/pim/space#PersonalStorage'>;
+    /** Aceess may not be open to the public. Contains preferences resources. */
+    "PreferencesWorkspace": NamedNode<'http://www.w3.org/ns/pim/space#PreferencesWorkspace'>;
+    /**
+     * Workspaces are place where data is stored, and associated polices of privacy.
+     * A given application typically stores information in several different
+     * workspaces, some being user private, some shared, and some public.
+     *
+     */
+    "Workspace": NamedNode<'http://www.w3.org/ns/pim/space#Workspace'>;
+    /**
+     * A public storage is a space of URIs in which you have access to data,
+     *     and all data is accessible to anyone without control.
+     *
+     */
+    "PublicStorage": NamedNode<'http://www.w3.org/ns/pim/space#PublicStorage'>;
+    /**
+     * Aceess is open to the public. Anything in a public workspace
+     *     can be accesed by anyone.
+     */
+    "PublicWorkspace": NamedNode<'http://www.w3.org/ns/pim/space#PublicWorkspace'>;
+    /** Access is to some but not all people. */
+    "SharedWorkspace": NamedNode<'http://www.w3.org/ns/pim/space#SharedWorkspace'>;
+    "masterWorkspace": NamedNode<'http://www.w3.org/ns/pim/space#masterWorkspace'>;
+    "preferencesFile": NamedNode<'http://www.w3.org/ns/pim/space#preferencesFile'>;
+    /**
+     * The storage in which this workspace is, or the storage which
+     * contains this resource, or a storage available to this agent to use.
+     */
+    "storage": NamedNode<'http://www.w3.org/ns/pim/space#storage'>;
+    /**
+     * URIs which start with this string are in this workspace or storage.
+     * This may be used for constructing URIs for new storage resources.
+     *
+     */
+    "uriPrefix": NamedNode<'http://www.w3.org/ns/pim/space#uriPrefix'>;
+    "workspace": NamedNode<'http://www.w3.org/ns/pim/space#workspace'>;
+}
+export declare const strict: Record<keyof Pim, NamedNode<string>> & ((property?: TemplateStringsArray | keyof Pim | undefined) => NamedNode<string>) & Pim;
+export declare const loose: Record<any, NamedNode<string>> & ((property?: any) => NamedNode<string>) & Pim;
+export {};
+//# sourceMappingURL=pim.d.ts.map

package/vocabularies/pim.js

@@ -0,0 +1,4 @@
+import namespace from "@rdfjs/namespace";
+const builder = namespace("http://www.w3.org/ns/pim/space#");
+export const strict = builder;
+export const loose = builder;

package/vocabularies/set.d.ts

@@ -0,0 +1,38 @@
+import { NamedNode } from "@rdfjs/types";
+interface Set {
+    '': NamedNode<'http://www.w3.org/2000/10/swap/set#'>;
+    /**
+     * The subject is a list of sets,
+     *     and the objet is the difference of the sets in the object
+     */
+    "difference": NamedNode<'http://www.w3.org/2000/10/swap/set#difference'>;
+    /**
+     * This set contains that as a member.
+     *     Cwm will bind the subject to each of the members of the object.
+     */
+    "in": NamedNode<'http://www.w3.org/2000/10/swap/set#in'>;
+    /**
+     * The subject is a list of sets,
+     *     and the objet is the intersection of the sets in the object
+     */
+    "intersection": NamedNode<'http://www.w3.org/2000/10/swap/set#intersection'>;
+    /**
+     * This is a member of that set.
+     *     Cwm will bind the object to each of the members of the suject.
+     */
+    "member": NamedNode<'http://www.w3.org/2000/10/swap/set#member'>;
+    /**
+     * The subject is a list of sets,
+     *     and the objet is the symmetricDifference of the sets in the object
+     */
+    "symmetricDifference": NamedNode<'http://www.w3.org/2000/10/swap/set#symmetricDifference'>;
+    /**
+     * The subject is a list [sic] of sets,
+     *     and the objet is the union of the sets in the object
+     */
+    "union": NamedNode<'http://www.w3.org/2000/10/swap/set#union'>;
+}
+export declare const strict: Record<keyof Set, NamedNode<string>> & ((property?: TemplateStringsArray | keyof Set | undefined) => NamedNode<string>) & Set;
+export declare const loose: Record<any, NamedNode<string>> & ((property?: any) => NamedNode<string>) & Set;
+export {};
+//# sourceMappingURL=set.d.ts.map

package/vocabularies/set.js

@@ -0,0 +1,4 @@
+import namespace from "@rdfjs/namespace";
+const builder = namespace("http://www.w3.org/2000/10/swap/set#");
+export const strict = builder;
+export const loose = builder;