@shaclmate/compiler 2.0.22 → 2.0.24

package/dist/generators/ts/TermType.js

@@ -12,18 +12,26 @@ import { Import } from "./Import.js";
 import { SnippetDeclarations } from "./SnippetDeclarations.js";
 import { Type } from "./Type.js";
 import { objectInitializer } from "./objectInitializer.js";
+import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
+import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 /**
  * Abstract base class for IdentifierType and LiteralType.
+ *
+ * ConstantTermT is the type of sh:defaultValue, sh:hasValue, and sh:in.
+ * RuntimeTermT is the type of values at runtime.
+ *
+ * The two are differentiated because identifiers can have BlankNode or NamedNode values at runtime but only NamedNode values for sh:defaultValue et al.
  */
 export class TermType extends Type {
     defaultValue;
-    equalsFunction = "booleanEquals";
+    equalsFunction = `${syntheticNamePrefix}booleanEquals`;
     hasValues;
     in_;
     mutable = false;
     nodeKinds;
-    constructor({ defaultValue, hasValues, in_, nodeKinds, ...superParameters }) {
-        super(superParameters);
+    typeof = "object";
+    constructor({ defaultValue, hasValues, in_, nodeKinds, }) {
+        super();
         this.defaultValue = defaultValue;
         this.hasValues = hasValues;
         this.in_ = in_;
@@ -34,26 +42,26 @@ export class TermType extends Type {
         const conversions = [];
         if (this.nodeKinds.has("Literal")) {
             conversions.push({
-                conversionExpression: (value) => `rdfLiteral.toRdf(${value}, ${objectInitializer({ dataFactory: this.dataFactoryVariable })})`,
+                conversionExpression: (value) => `rdfLiteral.toRdf(${value}, ${objectInitializer({ dataFactory: "dataFactory" })})`,
                 sourceTypeCheckExpression: (value) => `typeof ${value} === "boolean"`,
                 sourceTypeName: "boolean",
             }, {
-                conversionExpression: (value) => `rdfLiteral.toRdf(${value}, ${objectInitializer({ dataFactory: this.dataFactoryVariable })})`,
+                conversionExpression: (value) => `rdfLiteral.toRdf(${value}, ${objectInitializer({ dataFactory: "dataFactory" })})`,
                 sourceTypeCheckExpression: (value) => `typeof ${value} === "object" && ${value} instanceof Date`,
                 sourceTypeName: "Date",
             }, {
-                conversionExpression: (value) => `rdfLiteral.toRdf(${value}, ${objectInitializer({ dataFactory: this.dataFactoryVariable })})`,
+                conversionExpression: (value) => `rdfLiteral.toRdf(${value}, ${objectInitializer({ dataFactory: "dataFactory" })})`,
                 sourceTypeCheckExpression: (value) => `typeof ${value} === "number"`,
                 sourceTypeName: "number",
             }, {
-                conversionExpression: (value) => `${this.dataFactoryVariable}.literal(${value})`,
+                conversionExpression: (value) => `dataFactory.literal(${value})`,
                 sourceTypeCheckExpression: (value) => `typeof ${value} === "string"`,
                 sourceTypeName: "string",
             });
         }
         this.defaultValue.ifJust((defaultValue) => {
             conversions.push({
-                conversionExpression: () => this.rdfjsTermExpression(defaultValue),
+                conversionExpression: () => rdfjsTermExpression(defaultValue),
                 sourceTypeCheckExpression: (value) => `typeof ${value} === "undefined"`,
                 sourceTypeName: "undefined",
             });
@@ -68,17 +76,21 @@ export class TermType extends Type {
     get discriminatorProperty() {
         return Maybe.of({
             name: "termType",
+            ownValues: [...this.nodeKinds],
+            descendantValues: [],
             type: "string",
-            values: [...this.nodeKinds],
         });
     }
+    get graphqlName() {
+        throw new Error("not implemented");
+    }
     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]
+        return new Type.JsonName(`{ 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" }`;
+            .join(" | ")} } | { readonly "@language"?: string, readonly "@type"?: string, readonly "@value": string, readonly termType: "Literal" }`);
     }
     get name() {
         return `(${[...this.nodeKinds]
@@ -92,13 +104,13 @@ export class TermType extends Type {
             let valueToNodeKind;
             switch (nodeKind) {
                 case "BlankNode":
-                    valueToNodeKind = `${this.dataFactoryVariable}.blankNode(${variables.value}["@id"].substring(2))`;
+                    valueToNodeKind = `dataFactory.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))`;
+                    valueToNodeKind = `dataFactory.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"])`;
+                    valueToNodeKind = `dataFactory.namedNode(${variables.value}["@id"])`;
                     break;
                 default:
                     throw new RangeError(nodeKind);
@@ -108,31 +120,54 @@ export class TermType extends Type {
                 : `((${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()");
+    fromRdfExpression(parameters) {
+        // invariant(
+        //   this.nodeKinds.has("Literal") &&
+        //     (this.nodeKinds.has("BlankNode") || this.nodeKinds.has("NamedNode")),
+        //   "IdentifierType and LiteralType should override",
+        // );
+        const chain = this.fromRdfExpressionChain(parameters);
+        const { variables } = parameters;
+        return [
+            variables.resourceValues,
+            chain.defaultValue,
+            chain.hasValues,
+            chain.languageIn,
+            chain.valueTo,
+        ]
+            .filter((_) => typeof _ !== "undefined")
+            .join(".");
+    }
+    fromRdfExpressionChain({ variables, }) {
+        let valueToExpression = "purify.Either.of<Error, rdfjs.BlankNode | rdfjs.Literal | rdfjs.NamedNode>(value.toTerm())";
+        if (this.nodeKinds.size < 3) {
+            const eitherTypeParameters = `<Error, ${this.name}>`;
+            valueToExpression = `${valueToExpression}.chain(term => {
+  switch (term.termType) {
+  ${[...this.nodeKinds].map((nodeKind) => `case "${nodeKind}":`).join("\n")} return purify.Either.of${eitherTypeParameters}(term);
+  default: return purify.Left${eitherTypeParameters}(new rdfjsResource.Resource.MistypedValueError(${objectInitializer({ actualValue: "term", expectedValueType: JSON.stringify(this.name), focusResource: variables.resource, predicate: variables.predicate })}));         
+}})`;
         }
-        // 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(".");
+        return {
+            defaultValue: this.defaultValue
+                .map((defaultValue) => `map(values => values.length > 0 ? values : new rdfjsResource.Resource.Value(${objectInitializer({ subject: variables.resource, predicate: variables.predicate, object: rdfjsTermExpression(defaultValue) })}).toValues())`)
+                .extract(),
+            hasValues: this.hasValues.length > 0
+                ? `chain(values => {
+  for (const hasValue of [${this.hasValues.map(rdfjsTermExpression).join(", ")}]) {
+    const findResult = values.find(value => value.toTerm().equals(hasValue));
+    if (findResult.isLeft()) {
+      return findResult;
+    }
+  }
+  return purify.Either.of<Error, rdfjsResource.Resource.Values<rdfjsResource.Resource.Value>>(values);
+})`
+                : undefined,
+            valueTo: `chain(values => values.chainMap(value => ${valueToExpression}))`,
+        };
+    }
+    graphqlResolveExpression(_parameters) {
+        throw new Error("not implemented");
     }
     hashStatements({ variables, }) {
         return [
@@ -140,6 +175,9 @@ export class TermType extends Type {
             `${variables.hasher}.update(${variables.value}.value);`,
         ];
     }
+    jsonUiSchemaElement() {
+        return Maybe.empty();
+    }
     jsonZodSchema({ variables, }) {
         invariant(this.nodeKinds.has("Literal") &&
             (this.nodeKinds.has("BlankNode") || this.nodeKinds.has("NamedNode")), "IdentifierType and LiteralType should override");
@@ -159,7 +197,7 @@ export class TermType extends Type {
         })
             .join(", ")}])`;
     }
-    snippetDeclarations(features) {
+    snippetDeclarations({ features, }) {
         const snippetDeclarations = [];
         if (features.has("equals")) {
             snippetDeclarations.push(SnippetDeclarations.booleanEquals);
@@ -168,13 +206,13 @@ export class TermType extends Type {
     }
     sparqlWherePatterns(parameters) {
         switch (parameters.context) {
-            case "property":
+            case "object":
                 return this.defaultValue
                     .map(() => [
                     `{ patterns: [${super.sparqlWherePatterns(parameters).join(", ")}], type: "optional" }`,
                 ])
                     .orDefault(super.sparqlWherePatterns(parameters));
-            case "type":
+            case "subject":
                 return super.sparqlWherePatterns(parameters);
         }
     }
@@ -203,7 +241,7 @@ export class TermType extends Type {
     }
     toRdfExpression({ variables, }) {
         return this.defaultValue
-            .map((defaultValue) => `!${variables.value}.equals(${this.rdfjsTermExpression(defaultValue)}) ? ${variables.value} : undefined`)
+            .map((defaultValue) => `!${variables.value}.equals(${rdfjsTermExpression(defaultValue)}) ? ${variables.value} : undefined`)
             .orDefault(variables.value);
     }
     useImports() {
@@ -213,33 +251,16 @@ export class TermType extends Type {
         }
         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, "conversions", null);
+__decorate([
+    Memoize()
+], TermType.prototype, "discriminatorProperty", null);
+__decorate([
+    Memoize()
+], TermType.prototype, "jsonName", null);
 __decorate([
     Memoize()
 ], TermType.prototype, "name", null);

package/dist/generators/ts/TsGenerator.d.ts

@@ -1,7 +1,8 @@
 import * as ast from "../../ast/index.js";
 import type { Generator } from "../Generator.js";
 export declare class TsGenerator implements Generator {
+    private readonly typeFactory;
     generate(ast_: ast.Ast): string;
-    private addDeclarations;
+    private addStatements;
 }
 //# sourceMappingURL=TsGenerator.d.ts.map

package/dist/generators/ts/TsGenerator.js

@@ -3,23 +3,22 @@ import * as ast from "../../ast/index.js";
 import { ObjectType } from "./ObjectType.js";
 import { ObjectUnionType } from "./ObjectUnionType.js";
 import { TypeFactory } from "./TypeFactory.js";
+import { graphqlSchemaVariableStatement } from "./graphqlSchemaVariableStatement.js";
+import { objectSetDeclarations } from "./objectSetDeclarations.js";
 export class TsGenerator {
+    typeFactory = new TypeFactory();
     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({
-            dataFactoryVariable: ast_.tsDataFactoryVariable,
-        });
-        this.addDeclarations({
-            objectTypes: sortedAstObjectTypes.flatMap((astObjectType) => {
-                const type = typeFactory.createTypeFromAstType(astObjectType);
+        this.addStatements({
+            objectTypes: ast.ObjectType.toposort(ast_.objectTypes).flatMap((astObjectType) => {
+                const type = this.typeFactory.createTypeFromAstType(astObjectType);
                 return type instanceof ObjectType ? [type] : [];
             }),
             objectUnionTypes: ast_.objectUnionTypes.flatMap((astObjectUnionType) => {
-                const type = typeFactory.createTypeFromAstType(astObjectUnionType);
+                const type = this.typeFactory.createTypeFromAstType(astObjectUnionType);
                 return type instanceof ObjectUnionType ? [type] : [];
             }),
             sourceFile,
@@ -27,9 +26,12 @@ export class TsGenerator {
         sourceFile.saveSync();
         return project.getFileSystem().readFileSync(sourceFile.getFilePath());
     }
-    addDeclarations({ objectTypes, objectUnionTypes, sourceFile, }) {
+    addStatements({ objectTypes, objectUnionTypes, sourceFile, }) {
         // sourceFile.addStatements(this.configuration.dataFactoryImport);
-        sourceFile.addStatements('import { DataFactory as dataFactory } from "n3"');
+        sourceFile.addStatements([
+            'import { DataFactory as dataFactory, StoreFactory as _DatasetFactory } from "n3";',
+            "const datasetFactory: rdfjs.DatasetCoreFactory = new _DatasetFactory();",
+        ]);
         const declaredTypes = [
             ...objectTypes,
             ...objectUnionTypes,
@@ -58,20 +60,32 @@ export class TsGenerator {
         // Deduplicate and add snippet declarations
         const addedSnippetDeclarations = new Set();
         for (const declaredType of declaredTypes) {
-            for (const snippetDeclaration of declaredType.snippetDeclarations(declaredType.features)) {
+            for (const snippetDeclaration of declaredType.snippetDeclarations({
+                features: declaredType.features,
+                recursionStack: [],
+            })) {
                 if (!addedSnippetDeclarations.has(snippetDeclaration)) {
                     sourceFile.addStatements([snippetDeclaration]);
                     addedSnippetDeclarations.add(snippetDeclaration);
                 }
             }
         }
-        // Add type declarations
         for (const objectType of objectTypes) {
             sourceFile.addStatements(objectType.declarations);
         }
         for (const objectUnionType of objectUnionTypes) {
             sourceFile.addStatements(objectUnionType.declarations);
         }
+        const objectTypesSortedByName = objectTypes.toSorted((left, right) => left.name.localeCompare(right.name));
+        const objectUnionTypesSortedByName = objectUnionTypes.toSorted((left, right) => left.name.localeCompare(right.name));
+        sourceFile.addStatements(objectSetDeclarations({
+            objectTypes: objectTypesSortedByName,
+            objectUnionTypes: objectUnionTypesSortedByName,
+        }));
+        sourceFile.addVariableStatements(graphqlSchemaVariableStatement({
+            objectTypes: objectTypesSortedByName,
+            objectUnionTypes: objectUnionTypesSortedByName,
+        }).toList());
     }
 }
 //# sourceMappingURL=TsGenerator.js.map

package/dist/generators/ts/Type.d.ts

@@ -1,5 +1,4 @@
-import type { BlankNode, Literal, NamedNode, Variable } from "@rdfjs/types";
-import { Maybe } from "purify-ts";
+import type { Maybe } from "purify-ts";
 import type { TsFeature } from "../../enums/index.js";
 import type { Import } from "./Import.js";
 /**
@@ -12,33 +11,38 @@ export declare abstract class Type {
      * Expressions that convert a source type or types to this type. It should include the type itself.
      */
     abstract readonly conversions: readonly Type.Conversion[];
+    /**
+     * A property that discriminates sub-types of this type e.g., termType on RDF/JS terms.
+     */
+    abstract readonly discriminatorProperty: Maybe<Type.DiscriminatorProperty>;
     /**
      * A function (reference or declaration) that compares two property values of this type, returning a
-     * EqualsResult.
+     * $EqualsResult.
      */
     abstract readonly equalsFunction: string;
     /**
-     * JSON-compatible returned by propertyToJsonExpression.
+     * GraphQL-compatible version of the type.
      */
-    abstract readonly jsonName: string;
+    abstract readonly graphqlName: Type.GraphqlName;
+    /**
+     * JSON-compatible version of the type.
+     */
+    abstract readonly jsonName: Type.JsonName;
     /**
      * Is a value of this type mutable?
      */
     abstract readonly mutable: boolean;
     /**
-     * Name of the type.
+     * TypeScript 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.
+     * JavaScript typeof the type.
      */
-    get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
+    abstract readonly typeof: "boolean" | "object" | "number" | "string";
     /**
-     * An expression that converts a JSON object in the same format as the propertyToJsonExpression to a value of this type.
+     * An expression that converts this type's JSON type to a value of this type. It doesn't return a purify.Either because the JSON has
+     * already been validated and converted to the expected JSON type with Zod.
      */
     abstract fromJsonExpression(parameters: {
         variables: {
@@ -46,18 +50,36 @@ export declare abstract class Type {
         };
     }): string;
     /**
-     * An expression that converts a rdfjsResource.Resource.Values to an Either of value/values
-     * of this type for a property.
+     * An expression that converts a purify.Either<Error, rdfjsResource.Resource.Values<rdfjsResource.Resource.Value>> to
+     * (1) a purify.Either<Error, rdfjsResource.Resource.Values<this type>> if this is an item type (identifier, object, et al.) or
+     * (2) a purify.Either<Error, cardinality type> if this is a cardinality type
+     *
+     * Some types need to filter on the set of all objects/values of a (subject, predicate). For example, all sh:hasValue values must be present in the set for any values
+     * to be considered valid. Similar
+     *
+     * Values may also need to be sorted. For example, applying sh:languageIn should sort the values in the order of the specified languages so that the first value
+     * (if it exists) is always of the first specified language -- a common situation when sh:maxCount is 1.
      */
     abstract fromRdfExpression(parameters: {
         variables: {
             context: string;
+            ignoreRdfType?: boolean;
             languageIn: string;
+            objectSet: string;
             predicate: string;
             resource: string;
             resourceValues: string;
         };
     }): string;
+    /**
+     * An expression that resolves a value of this type in the GraphQL server.
+     */
+    abstract graphqlResolveExpression(parameters: {
+        variables: {
+            args: string;
+            value: string;
+        };
+    }): string;
     /**
      * Statements that use hasher.update to hash a property value of this type.
      */
@@ -71,15 +93,22 @@ export declare abstract class Type {
     /**
      * Element object for a JSON Forms UI schema.
      */
-    jsonUiSchemaElement(_parameters: {
+    abstract jsonUiSchemaElement(parameters: {
         variables: {
             scopePrefix: string;
         };
     }): Maybe<string>;
     /**
-     * Zod schema for the JSON version of the type (the result of propertyToJson).
+     * Zod schema for the JSON type of this type.
+     *
+     * This method is called in two contexts:
+     * "property": from a ShaclProperty, while generating the z.object properties of an ObjectType
+     * "type": from another Type e.g., an OptionType or UnionType
+     *
+     * z.lazy() should only be returned for "property".
      */
     abstract jsonZodSchema(parameters: {
+        context: "property" | "type";
         variables: {
             zod: string;
         };
@@ -92,18 +121,22 @@ export declare abstract class Type {
      *
      * The generator deduplicates snippet declarations across all types before adding them to the source.
      */
-    snippetDeclarations(_features: Set<TsFeature>): readonly string[];
+    abstract snippetDeclarations(parameters: {
+        features: Set<TsFeature>;
+        recursionStack: Type[];
+    }): 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";
+     * (1) When an instance of the type is an "object" of a property.
+     *     This method should return a BGP (variables.subject, variables.predicate, variables.object) and recursively call itself with the variables.object as a "subject" context.
+     * (2) When an instance of the type is a "subject".
+     *     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 patterns should return an empty array.
+     */
+    sparqlConstructTemplateTriples({ allowIgnoreRdfType, context, variables, }: {
+        allowIgnoreRdfType: boolean;
+        context: "object";
         variables: {
             object: string;
             predicate: string;
@@ -111,7 +144,8 @@ export declare abstract class Type {
             variablePrefix: string;
         };
     } | {
-        context: "type";
+        allowIgnoreRdfType: boolean;
+        context: "subject";
         variables: {
             subject: string;
             variablePrefix: string;
@@ -122,17 +156,21 @@ export declare abstract class Type {
      *
      * See note in sparqlConstructTemplateTriples re: how this method is used.
      */
-    sparqlWherePatterns({ context, variables, }: {
-        context: "property";
+    sparqlWherePatterns({ allowIgnoreRdfType, context, variables, }: {
+        allowIgnoreRdfType: boolean;
+        context: "object";
         variables: {
+            languageIn: string;
             object: string;
             predicate: string;
             subject: string;
             variablePrefix: string;
         };
     } | {
-        context: "type";
+        allowIgnoreRdfType: boolean;
+        context: "subject";
         variables: {
+            languageIn: string;
             subject: string;
             variablePrefix: string;
         };
@@ -162,8 +200,9 @@ export declare abstract class Type {
     /**
      * 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;
+    abstract useImports(parameters: {
+        features: Set<TsFeature>;
+    }): readonly Import[];
 }
 export declare namespace Type {
     interface Conversion {
@@ -173,7 +212,36 @@ export declare namespace Type {
     }
     interface DiscriminatorProperty {
         readonly name: string;
-        readonly values: readonly string[];
+        readonly ownValues: readonly string[];
+        readonly descendantValues: readonly string[];
+    }
+    class JsonName {
+        /**
+         * Is the type optional in JSON? Equivalent to ? in TypeScript or | undefined.
+         */
+        readonly optional: boolean;
+        /**
+         * The name of the type when it's required i.e. -- so it should never include "| undefined".
+         */
+        readonly requiredName: string;
+        constructor(requiredName: string, parameters?: {
+            optional: boolean;
+        });
+        toString(): string;
+    }
+    class GraphqlName {
+        /**
+         * Is the type nullable in GraphQL?
+         */
+        readonly nullable: boolean;
+        /**
+         * The name of the type when it's nullable -- so it should never include "new graphql.GraphQLNonNull(...)" around it.
+         */
+        readonly nullableName: string;
+        constructor(nullableName: string, parameters?: {
+            nullable: boolean;
+        });
+        toString(): string;
     }
 }
 //# sourceMappingURL=Type.d.ts.map