@shaclmate/compiler 2.0.13 → 2.0.15

package/generators/ts/TermType.js

@@ -0,0 +1,242 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { xsd } from "@tpluscode/rdf-ns-builders";
+import { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
+import { Memoize } from "typescript-memoize";
+import { Import } from "./Import.js";
+import { SnippetDeclarations } from "./SnippetDeclarations.js";
+import { Type } from "./Type.js";
+import { objectInitializer } from "./objectInitializer.js";
+/**
+ * Abstract base class for IdentifierType and LiteralType.
+ */
+export class TermType extends Type {
+    constructor({ defaultValue, hasValues, in_, nodeKinds, ...superParameters }) {
+        super(superParameters);
+        this.equalsFunction = "booleanEquals";
+        this.mutable = false;
+        this.defaultValue = defaultValue;
+        this.hasValues = hasValues;
+        this.in_ = in_;
+        this.nodeKinds = new Set([...nodeKinds]);
+        invariant(this.nodeKinds.size > 0);
+    }
+    get conversions() {
+        const conversions = [];
+        if (this.nodeKinds.has("Literal")) {
+            conversions.push({
+                conversionExpression: (value) => `rdfLiteral.toRdf(${value})`,
+                sourceTypeCheckExpression: (value) => `typeof ${value} === "boolean"`,
+                sourceTypeName: "boolean",
+            }, {
+                conversionExpression: (value) => `rdfLiteral.toRdf(${value})`,
+                sourceTypeCheckExpression: (value) => `typeof ${value} === "object" && ${value} instanceof Date`,
+                sourceTypeName: "Date",
+            }, {
+                conversionExpression: (value) => `rdfLiteral.toRdf(${value})`,
+                sourceTypeCheckExpression: (value) => `typeof ${value} === "number"`,
+                sourceTypeName: "number",
+            }, {
+                conversionExpression: (value) => `${this.dataFactoryVariable}.literal(${value})`,
+                sourceTypeCheckExpression: (value) => `typeof ${value} === "string"`,
+                sourceTypeName: "string",
+            });
+        }
+        this.defaultValue.ifJust((defaultValue) => {
+            conversions.push({
+                conversionExpression: () => this.rdfjsTermExpression(defaultValue),
+                sourceTypeCheckExpression: (value) => `typeof ${value} === "undefined"`,
+                sourceTypeName: "undefined",
+            });
+        });
+        conversions.push({
+            conversionExpression: (value) => value,
+            sourceTypeCheckExpression: (value) => `typeof ${value} === "object"`,
+            sourceTypeName: this.name,
+        });
+        return conversions;
+    }
+    get discriminatorProperty() {
+        return Maybe.of({
+            name: "termType",
+            type: "string",
+            values: [...this.nodeKinds],
+        });
+    }
+    get jsonName() {
+        invariant(this.nodeKinds.has("Literal") &&
+            (this.nodeKinds.has("BlankNode") || this.nodeKinds.has("NamedNode")), "IdentifierType and LiteralType should override");
+        return `{ readonly "@id": string, readonly termType: ${[...this.nodeKinds]
+            .filter((nodeKind) => nodeKind !== "Literal")
+            .map((nodeKind) => `"${nodeKind}"`)
+            .join(" | ")} } | { readonly "@language": string | undefined, readonly "@type": string | undefined, readonly "@value": string, readonly termType: "Literal" }`;
+    }
+    get name() {
+        return `(${[...this.nodeKinds]
+            .map((nodeKind) => `rdfjs.${nodeKind}`)
+            .join(" | ")})`;
+    }
+    fromJsonExpression({ variables, }) {
+        invariant(this.nodeKinds.has("Literal") &&
+            (this.nodeKinds.has("BlankNode") || this.nodeKinds.has("NamedNode")), "IdentifierType and LiteralType should override");
+        return [...this.nodeKinds].reduce((expression, nodeKind) => {
+            let valueToNodeKind;
+            switch (nodeKind) {
+                case "BlankNode":
+                    valueToNodeKind = `${this.dataFactoryVariable}.blankNode(${variables.value}["@id"].substring(2))`;
+                    break;
+                case "Literal":
+                    valueToNodeKind = `${this.dataFactoryVariable}.literal(${variables.value}["@value"], typeof ${variables.value}["@language"] !== "undefined" ? ${variables.value}["@language"] : (typeof ${variables.value}["@type"] !== "undefined" ? dataFactory.namedNode(${variables.value}["@type"]) : undefined))`;
+                    break;
+                case "NamedNode":
+                    valueToNodeKind = `${this.dataFactoryVariable}.namedNode(${variables.value}["@id"])`;
+                    break;
+                default:
+                    throw new RangeError(nodeKind);
+            }
+            return expression.length === 0
+                ? valueToNodeKind
+                : `((${variables.value}.termType === "${nodeKind}") ? (${valueToNodeKind}) : (${expression}))`;
+        }, "");
+    }
+    fromRdfExpression({ variables, }) {
+        const chain = [
+            this.propertyFilterRdfResourceValuesExpression({ variables }),
+        ];
+        // Have an rdfjsResource.Resource.Values here
+        if (this.hasValues.length === 1) {
+            chain.push(`find(_value => _value.toTerm().equals(${this.rdfjsTermExpression(this.hasValues[0])}))`);
+        }
+        else {
+            chain.push("head()");
+        }
+        // Have an rdfjsResource.Resource.Value here
+        this.defaultValue.ifJust((defaultValue) => {
+            // alt the default value before trying to convert the rdfjsResource.Resource.Value to the type
+            chain.push(`alt(purify.Either.of(new rdfjsResource.Resource.Value(${objectInitializer({ subject: variables.resource, predicate: variables.predicate, object: this.rdfjsTermExpression(defaultValue) })})))`);
+        });
+        // Last step: convert the rdfjsResource.Resource.Value to the type
+        chain.push(`chain(_value => ${this.propertyFromRdfResourceValueExpression({
+            variables: {
+                predicate: variables.predicate,
+                resource: variables.resource,
+                resourceValue: "_value",
+            },
+        })})`);
+        return chain.join(".");
+    }
+    hashStatements({ variables, }) {
+        return [
+            `${variables.hasher}.update(${variables.value}.termType);`,
+            `${variables.hasher}.update(${variables.value}.value);`,
+        ];
+    }
+    jsonZodSchema({ variables, }) {
+        invariant(this.nodeKinds.has("Literal") &&
+            (this.nodeKinds.has("BlankNode") || this.nodeKinds.has("NamedNode")), "IdentifierType and LiteralType should override");
+        return `${variables.zod}.discriminatedUnion("termType", [${[
+            ...this.nodeKinds,
+        ]
+            .map((nodeKind) => {
+            switch (nodeKind) {
+                case "BlankNode":
+                case "NamedNode":
+                    return `${variables.zod}.object({ "@id": ${variables.zod}.string().min(1), termType: ${variables.zod}.literal("${nodeKind}") })`;
+                case "Literal":
+                    return `${variables.zod}.object({ "@language": ${variables.zod}.string().optional(), "@type": ${variables.zod}.string().optional(), "@value": ${variables.zod}.string(), termType: ${variables.zod}.literal("Literal") })`;
+                default:
+                    throw new RangeError(nodeKind);
+            }
+        })
+            .join(", ")}])`;
+    }
+    snippetDeclarations(features) {
+        const snippetDeclarations = [];
+        if (features.has("equals")) {
+            snippetDeclarations.push(SnippetDeclarations.booleanEquals);
+        }
+        return snippetDeclarations;
+    }
+    sparqlWherePatterns(parameters) {
+        switch (parameters.context) {
+            case "property":
+                return this.defaultValue
+                    .map(() => [
+                    `{ patterns: [${super.sparqlWherePatterns(parameters).join(", ")}], type: "optional" }`,
+                ])
+                    .orDefault(super.sparqlWherePatterns(parameters));
+            case "type":
+                return super.sparqlWherePatterns(parameters);
+        }
+    }
+    toJsonExpression({ variables, }) {
+        invariant(this.nodeKinds.has("Literal") &&
+            (this.nodeKinds.has("BlankNode") || this.nodeKinds.has("NamedNode")), "IdentifierType and LiteralType should override");
+        return [...this.nodeKinds].reduce((expression, nodeKind) => {
+            let valueToNodeKind;
+            switch (nodeKind) {
+                case "BlankNode":
+                    valueToNodeKind = `{ "@id": \`_:\${${variables.value}.value}\`, termType: "${nodeKind}" as const }`;
+                    break;
+                case "Literal":
+                    valueToNodeKind = `{ "@language": ${variables.value}.language.length > 0 ? ${variables.value}.language : undefined, "@type": ${variables.value}.datatype.value !== "${xsd.string.value}" ? ${variables.value}.datatype.value : undefined, "@value": ${variables.value}.value, termType: "${nodeKind}" as const }`;
+                    break;
+                case "NamedNode":
+                    valueToNodeKind = `{ "@id": ${variables.value}.value, termType: "${nodeKind}" as const }`;
+                    break;
+                default:
+                    throw new RangeError(nodeKind);
+            }
+            return expression.length === 0
+                ? valueToNodeKind
+                : `(${variables.value}.termType === "${nodeKind}") ? ${valueToNodeKind} : ${expression}`;
+        }, "");
+    }
+    toRdfExpression({ variables, }) {
+        return this.defaultValue
+            .map((defaultValue) => `!${variables.value}.equals(${this.rdfjsTermExpression(defaultValue)}) ? ${variables.value} : undefined`)
+            .orDefault(variables.value);
+    }
+    useImports() {
+        const imports = [Import.RDFJS_TYPES];
+        if (this.nodeKinds.has("Literal")) {
+            imports.push(Import.RDF_LITERAL);
+        }
+        return imports;
+    }
+    /**
+     * Filter the rdfjsResource.Resource.Values to those that are relevant to the type.
+     *
+     * This is done before
+     */
+    propertyFilterRdfResourceValuesExpression({ variables, }) {
+        return variables.resourceValues;
+    }
+    /**
+     * Convert an rdfjsResource.Resource.Value to a value of this type.
+     * @param variables
+     * @protected
+     */
+    propertyFromRdfResourceValueExpression({ variables, }) {
+        invariant(this.nodeKinds.has("Literal") &&
+            (this.nodeKinds.has("BlankNode") || this.nodeKinds.has("NamedNode")), "IdentifierType and LiteralType should override");
+        let expression = `purify.Either.of(${variables.resourceValue}.toTerm())`;
+        if (this.nodeKinds.size < 3) {
+            expression = `${expression}.chain(term => {
+  switch (term.termType) {
+  ${[...this.nodeKinds].map((nodeKind) => `case "${nodeKind}":`).join("\n")} return purify.Either.of(term);
+  default: return purify.Left(new rdfjsResource.Resource.MistypedValueError(${objectInitializer({ actualValue: "term", expectedValueType: JSON.stringify(this.name), focusResource: variables.resource, predicate: variables.predicate })}));         
+}})`;
+        }
+        return expression;
+    }
+}
+__decorate([
+    Memoize()
+], TermType.prototype, "name", null);
+//# sourceMappingURL=TermType.js.map

package/generators/ts/TsGenerator.d.ts

@@ -1,15 +1,7 @@
-import type * as ast from "../../ast";
-import { Configuration as GlobalConfiguration } from "./Configuration.js";
-export declare class TsGenerator {
-    private ast;
-    protected readonly configuration: TsGenerator.Configuration;
-    constructor(ast: ast.Ast, configuration?: TsGenerator.Configuration);
-    generate(): string;
+import * as ast from "../../ast/index.js";
+import type { Generator } from "../Generator.js";
+export declare class TsGenerator implements Generator {
+    generate(ast_: ast.Ast): string;
     private addDeclarations;
-    private addImportDeclarations;
-}
-export declare namespace TsGenerator {
-    const Configuration: typeof GlobalConfiguration;
-    type Configuration = GlobalConfiguration;
 }
 //# sourceMappingURL=TsGenerator.d.ts.map

package/generators/ts/TsGenerator.js

@@ -1,119 +1,77 @@
-import { Project, StructureKind, } from "ts-morph";
-import { Configuration as GlobalConfiguration } from "./Configuration.js";
+import { Project, } from "ts-morph";
+import * as ast from "../../ast/index.js";
+import { ObjectType } from "./ObjectType.js";
+import { ObjectUnionType } from "./ObjectUnionType.js";
 import { TypeFactory } from "./TypeFactory.js";
-import { tsName } from "./tsName.js";
 export class TsGenerator {
-    constructor(ast, configuration) {
-        this.ast = ast;
-        this.configuration = configuration ?? new TsGenerator.Configuration();
-    }
-    generate() {
-        const astObjectTypes = this.ast.objectTypes.concat();
-        astObjectTypes.sort((left, right) => {
-            if (left.ancestorObjectTypes.some((ancestorObjectType) => ancestorObjectType.name.identifier.equals(right.name.identifier))) {
-                // Right is an ancestor of left, right must come first
-                return 1;
-            }
-            if (right.ancestorObjectTypes.some((ancestorObjectType) => ancestorObjectType.name.identifier.equals(left.name.identifier))) {
-                // Left is an ancestor of right, left must come first
-                return -1;
-            }
-            // Neither is an ancestor of the other, sort by name
-            return tsName(left.name).localeCompare(tsName(right.name));
-        });
+    generate(ast_) {
+        const sortedAstObjectTypes = ast.ObjectType.toposort(ast_.objectTypes);
         const project = new Project({
             useInMemoryFileSystem: true,
         });
         const sourceFile = project.createSourceFile("generated.ts");
-        const typeFactory = new TypeFactory({ configuration: this.configuration });
-        const objectTypes = astObjectTypes.flatMap((astObjectType) => {
-            const type = typeFactory.createTypeFromAstType(astObjectType);
-            return type.kind === "ObjectType" ? [type] : [];
+        const typeFactory = new TypeFactory({
+            dataFactoryVariable: ast_.tsDataFactoryVariable,
+        });
+        this.addDeclarations({
+            objectTypes: sortedAstObjectTypes.flatMap((astObjectType) => {
+                const type = typeFactory.createTypeFromAstType(astObjectType);
+                return type instanceof ObjectType ? [type] : [];
+            }),
+            objectUnionTypes: ast_.objectUnionTypes.flatMap((astObjectUnionType) => {
+                const type = typeFactory.createTypeFromAstType(astObjectUnionType);
+                return type instanceof ObjectUnionType ? [type] : [];
+            }),
+            sourceFile,
         });
-        this.addDeclarations(objectTypes, sourceFile);
         sourceFile.saveSync();
         return project.getFileSystem().readFileSync(sourceFile.getFilePath());
     }
-    addDeclarations(objectTypes, sourceFile) {
-        this.addImportDeclarations(objectTypes, sourceFile);
-        for (const objectType of objectTypes) {
-            switch (this.configuration.objectTypeDeclarationType) {
-                case "class":
-                    sourceFile.addClass(objectType.classDeclaration());
-                    break;
-                case "interface":
-                    sourceFile.addInterface(objectType.interfaceDeclaration());
-                    break;
-            }
-            const moduleStatements = [];
-            if (this.configuration.features.has("equals") &&
-                this.configuration.objectTypeDeclarationType === "interface") {
-                moduleStatements.push(objectType.equalsFunctionDeclaration());
-            }
-            if (this.configuration.features.has("fromRdf")) {
-                moduleStatements.push(objectType.fromRdfFunctionDeclaration());
-            }
-            if (this.configuration.features.has("hash")) {
-                moduleStatements.push(objectType.hashFunctionDeclaration());
-            }
-            if (this.configuration.features.has("sparql-graph-patterns")) {
-                if (objectType.parentObjectTypes.length > 1) {
-                    throw new RangeError(`object type '${objectType.name}' has multiple super object types, can't use with SPARQL graph patterns`);
+    addDeclarations({ objectTypes, objectUnionTypes, sourceFile, }) {
+        // sourceFile.addStatements(this.configuration.dataFactoryImport);
+        sourceFile.addStatements('import { DataFactory as dataFactory } from "n3"');
+        const declaredTypes = [
+            ...objectTypes,
+            ...objectUnionTypes,
+        ];
+        // Gather imports
+        const imports = [];
+        for (const declaredType of declaredTypes) {
+            imports.push(...declaredType.declarationImports);
+        }
+        // Deduplicate and add imports
+        const addedStringImports = new Set();
+        const addedStructureImports = [];
+        for (const import_ of imports) {
+            if (typeof import_ === "string") {
+                if (!addedStringImports.has(import_)) {
+                    sourceFile.addStatements([import_]);
                 }
-                moduleStatements.push(objectType.sparqlGraphPatternsClassDeclaration());
+                addedStringImports.add(import_);
+                continue;
             }
-            if (this.configuration.features.has("toRdf") &&
-                this.configuration.objectTypeDeclarationType === "interface") {
-                moduleStatements.push(objectType.toRdfFunctionDeclaration());
+            if (!addedStructureImports.find((addedStructureImport) => addedStructureImport.moduleSpecifier === import_.moduleSpecifier)) {
+                sourceFile.addStatements([import_]);
+                addedStructureImports.push(import_);
             }
-            sourceFile.addModule({
-                isExported: objectType.export_,
-                kind: StructureKind.Module,
-                name: objectType.name,
-                statements: moduleStatements,
-            });
-        }
-    }
-    addImportDeclarations(objectTypes, sourceFile) {
-        sourceFile.addImportDeclaration({
-            moduleSpecifier: "purify-ts",
-            namespaceImport: "purify",
-        });
-        sourceFile.addImportDeclaration({
-            isTypeOnly: true,
-            moduleSpecifier: "@rdfjs/types",
-            namespaceImport: "rdfjs",
-        });
-        sourceFile.addStatements(this.configuration.dataFactoryImport);
-        if (this.configuration.features.has("equals")) {
-            sourceFile.addImportDeclaration({
-                moduleSpecifier: "purify-ts-helpers",
-                namespaceImport: "purifyHelpers",
-            });
         }
-        if (this.configuration.features.has("fromRdf") ||
-            this.configuration.features.has("toRdf")) {
-            sourceFile.addImportDeclaration({
-                moduleSpecifier: "rdfjs-resource",
-                namespaceImport: "rdfjsResource",
-            });
-        }
-        if (this.configuration.features.has("sparql-graph-patterns")) {
-            sourceFile.addImportDeclaration({
-                moduleSpecifier: "@kos-kit/sparql-builder",
-                namespaceImport: "sparqlBuilder",
-            });
+        // Deduplicate and add snippet declarations
+        const addedSnippetDeclarations = new Set();
+        for (const declaredType of declaredTypes) {
+            for (const snippetDeclaration of declaredType.snippetDeclarations(declaredType.features)) {
+                if (!addedSnippetDeclarations.has(snippetDeclaration)) {
+                    sourceFile.addStatements([snippetDeclaration]);
+                    addedSnippetDeclarations.add(snippetDeclaration);
+                }
+            }
         }
-        const typeImportStatements = new Set();
+        // Add type declarations
         for (const objectType of objectTypes) {
-            for (const importStatement of objectType.importStatements) {
-                typeImportStatements.add(importStatement);
-            }
+            sourceFile.addStatements(objectType.declarations);
+        }
+        for (const objectUnionType of objectUnionTypes) {
+            sourceFile.addStatements(objectUnionType.declarations);
         }
-        sourceFile.addStatements([...typeImportStatements]);
     }
 }
-(function (TsGenerator) {
-    TsGenerator.Configuration = GlobalConfiguration;
-})(TsGenerator || (TsGenerator = {}));
 //# sourceMappingURL=TsGenerator.js.map

package/generators/ts/Type.d.ts

@@ -1,73 +1,153 @@
+import type { BlankNode, Literal, NamedNode, Variable } from "@rdfjs/types";
 import { Maybe } from "purify-ts";
-import type * as ast from "../../ast";
-import type { Configuration } from "./Configuration.js";
+import type { TsFeature } from "../../enums/index.js";
+import type { Import } from "./Import.js";
+/**
+ * Abstract base class for generating TypeScript expressions and statemenst in the TypeScript generator.
+ *
+ * Subclasses are used for both property types (c.f., property* methods) and node/object types.
+ */
 export declare abstract class Type {
-    abstract readonly kind: ast.Type["kind"] | "ListType";
-    abstract readonly name: string;
-    protected readonly configuration: Configuration;
-    constructor({ configuration, }: {
-        configuration: Configuration;
-    });
     /**
      * Expressions that convert a source type or types to this type. It should include the type itself.
      */
-    get conversions(): readonly Type.Conversion[];
+    abstract readonly conversions: readonly Type.Conversion[];
     /**
-     * A property that discriminates sub-types of this type e.g., termType on RDF/JS terms.
+     * A function (reference or declaration) that compares two property values of this type, returning a
+     * EqualsResult.
      */
-    get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
+    abstract readonly equalsFunction: string;
     /**
-     * Imports used by other methods on this type.
+     * JSON-compatible returned by propertyToJsonExpression.
      */
-    get importStatements(): readonly string[];
+    abstract readonly jsonName: string;
     /**
-     * An optional sparqlBuilder.GraphPattern expression that's chained to the object of another pattern, such as a list item.
-     *
-     * If the type is e.g., an RDF/JS term it won't have additional graph patterns beyond the basic (s, p, o), and this
-     * method will return nothing.
+     * Is a value of this type mutable?
      */
-    chainSparqlGraphPatternExpression(_: {
-        variables: {
-            subject: string;
-        };
-    }): Maybe<Type.SparqlGraphPatternExpression | Type.SparqlGraphPatternsExpression>;
+    abstract readonly mutable: boolean;
+    /**
+     * Name of the type.
+     */
+    abstract readonly name: string;
+    protected readonly dataFactoryVariable: string;
+    constructor({ dataFactoryVariable, }: {
+        dataFactoryVariable: string;
+    });
+    /**
+     * A property that discriminates sub-types of this type e.g., termType on RDF/JS terms.
+     */
+    get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
     /**
-     * A function (reference or declaration) that compares two values of this type, returning a
-     * purifyHelpers.Equatable.EqualsResult.
+     * An expression that converts a JSON object in the same format as the propertyToJsonExpression to a value of this type.
      */
-    abstract equalsFunction(): string;
+    abstract fromJsonExpression(parameters: {
+        variables: {
+            value: string;
+        };
+    }): string;
     /**
      * An expression that converts a rdfjsResource.Resource.Values to an Either of value/values
-     * of this type.
+     * of this type for a property.
      */
     abstract fromRdfExpression(parameters: {
         variables: {
+            context: string;
+            languageIn: string;
             predicate: string;
             resource: string;
             resourceValues: string;
         };
     }): string;
     /**
-     * Statements that use hasher.update to hash a value of this type.
+     * Statements that use hasher.update to hash a property value of this type.
      */
     abstract hashStatements(parameters: {
+        depth: number;
         variables: {
             hasher: string;
             value: string;
         };
     }): readonly string[];
     /**
-     * An sparqlBuilder.GraphPattern expression for a property, typically building a basic graph pattern.
+     * Element object for a JSON Forms UI schema.
+     */
+    jsonUiSchemaElement(_parameters: {
+        variables: {
+            scopePrefix: string;
+        };
+    }): Maybe<string>;
+    /**
+     * Zod schema for the JSON version of the type (the result of propertyToJson).
+     */
+    abstract jsonZodSchema(parameters: {
+        variables: {
+            zod: string;
+        };
+    }): string;
+    /**
+     * Reusable function, type, and other declarations that are not particular to this type but that type-specific code
+     * relies on. For example, the equals function/method of ObjectType has a custom return type that's the same across all
+     * ObjectType's. Instead of re-declaring the return type anonymously on every equals function, declare a named type
+     * as a snippet and reference it.
+     *
+     * The generator deduplicates snippet declarations across all types before adding them to the source.
+     */
+    snippetDeclarations(_features: Set<TsFeature>): readonly string[];
+    /**
+     * An array of SPARQL.js CONSTRUCT template triples for a value of this type, as strings (so they can incorporate runtime calls).
+     *
+     * This method is called in two contexts:
+     * (1) By an ObjectType.Property. The property expects a basic graph pattern (subject, property path, property object). The property calls this method to get additional triples in which the propertyObject is the subject. For example, if the type is a nested object, it would include (propertyObject, nestedPredicate, nestedObject) triples.
+     * (2) By another Type. For example, ListType calls this method to with the item variable as a subject in order to chain additional patterns on items.
+     *
+     * Term types with no additional properties should return an empty array.
+     */
+    sparqlConstructTemplateTriples({ context, variables, }: {
+        context: "property";
+        variables: {
+            object: string;
+            predicate: string;
+            subject: string;
+            variablePrefix: string;
+        };
+    } | {
+        context: "type";
+        variables: {
+            subject: string;
+            variablePrefix: string;
+        };
+    }): readonly string[];
+    /**
+     * An array of SPARQL.js where patterns for a value of this type, as strings (so they can incorporate runtime calls).
+     *
+     * See note in sparqlConstructTemplateTriples re: how this method is used.
      */
-    propertySparqlGraphPatternExpression({ variables, }: {
+    sparqlWherePatterns({ context, variables, }: {
+        context: "property";
         variables: {
             object: string;
             predicate: string;
             subject: string;
+            variablePrefix: string;
+        };
+    } | {
+        context: "type";
+        variables: {
+            subject: string;
+            variablePrefix: string;
         };
-    }): Type.SparqlGraphPatternExpression | Type.SparqlGraphPatternsExpression;
+    }): readonly string[];
     /**
-     * An expression that converts a value of this type to one that that can be .add'd to
+     * An expression that converts a value of this type to a JSON-LD compatible value. It can assume the presence
+     * of the correct JSON-LD context.
+     */
+    abstract toJsonExpression(parameters: {
+        variables: {
+            value: string;
+        };
+    }): string;
+    /**
+     * An expression that converts a property value of this type to one that that can be .add'd to
      * an rdfjsResource.Resource.
      */
     abstract toRdfExpression(parameters: {
@@ -79,30 +159,21 @@ export declare abstract class Type {
             value: string;
         };
     }): string;
+    /**
+     * Imports necessary to use this type.
+     */
+    useImports(_features: Set<TsFeature>): readonly Import[];
+    protected rdfjsTermExpression(rdfjsTerm: Omit<BlankNode, "equals"> | Omit<Literal, "equals"> | Omit<NamedNode, "equals"> | Omit<Variable, "equals">): string;
 }
 export declare namespace Type {
     interface Conversion {
         readonly conversionExpression: (value: string) => string;
-        readonly sourceTypeCheckExpression?: (value: string) => string;
+        readonly sourceTypeCheckExpression: (value: string) => string;
         readonly sourceTypeName: string;
     }
     interface DiscriminatorProperty {
         readonly name: string;
         readonly values: readonly string[];
     }
-    class SparqlGraphPatternExpression {
-        private readonly value;
-        constructor(value: string);
-        toSparqlGraphPatternExpression(): this;
-        toSparqlGraphPatternsExpression(): SparqlGraphPatternExpression;
-        toString(): string;
-    }
-    class SparqlGraphPatternsExpression {
-        private readonly value;
-        constructor(value: string);
-        toSparqlGraphPatternExpression(): SparqlGraphPatternExpression;
-        toSparqlGraphPatternsExpression(): this;
-        toString(): string;
-    }
 }
 //# sourceMappingURL=Type.d.ts.map