@shaclmate/compiler 4.0.40 → 4.0.42

package/dist/generators/ts/AbstractNumericType.d.ts

@@ -8,17 +8,11 @@ export declare abstract class AbstractNumericType<ValueT extends bigint | number
     abstract readonly kind: "BigInt" | "Float" | "Int";
     get filterFunction(): Code;
     get filterType(): Code;
-    get expression(): Code;
     get schemaType(): Code;
     get valueSparqlWherePatternsFunction(): Code;
+    protected get inlineExpression(): Code;
     jsonSchema(_parameters: Parameters<AbstractPrimitiveType<ValueT>["jsonSchema"]>[0]): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<string>["toRdfResourceValuesExpression"]>[0]): Code;
-    protected fromRdfResourceValuesExpressionChain({ variables, }: Parameters<AbstractPrimitiveType<ValueT>["fromRdfResourceValuesExpressionChain"]>[0]): ReturnType<AbstractPrimitiveType<ValueT>["fromRdfResourceValuesExpressionChain"]>;
-    protected abstract fromRdfResourceValueExpression(variables: {
-        variables: {
-            value: Code;
-        };
-    }): Code;
 }
 export declare namespace AbstractNumericType {
     const JsonType: typeof import("./AbstractType.js").AbstractType.JsonType;

package/dist/generators/ts/AbstractNumericType.js

@@ -13,45 +13,35 @@ import { code, joinCode } from "./ts-poet-wrapper.js";
 export class AbstractNumericType extends AbstractPrimitiveType {
     hashFunction = code `${this.reusables.snippets.hashNumeric}`;
     get filterFunction() {
-        return code `${this.reusables.snippets.filterNumeric}<${this.typeofs[0]}>`;
+        return code `${this.reusables.snippets.filterNumeric}<${this.expression}>`;
     }
     get filterType() {
-        return code `${this.reusables.snippets.NumericFilter}<${this.typeofs[0]}>`;
-    }
-    get expression() {
-        if (this.primitiveIn.length > 0) {
-            return code `${joinCode(this.primitiveIn.map((value) => this.literalExpression(value)), { on: " | " })}`;
-        }
-        return code `${this.typeofs[0]}`;
+        return code `${this.reusables.snippets.NumericFilter}<${this.expression}>`;
     }
     get schemaType() {
-        return code `${this.reusables.snippets.NumericSchema}<${this.typeofs[0]}>`;
+        return code `${this.reusables.snippets.NumericSchema}<${this.expression}>`;
     }
     get valueSparqlWherePatternsFunction() {
-        return code `${this.reusables.snippets.numericSparqlWherePatterns}<${this.typeofs[0]}>`;
+        return code `${this.reusables.snippets.numericSparqlWherePatterns}<${this.expression}>`;
+    }
+    get inlineExpression() {
+        if (this.primitiveIn.length > 0) {
+            return code `${joinCode(this.primitiveIn.map((value) => this.literalValueExpression(value)), { on: " | " })}`;
+        }
+        return code `${this.jsTypes[0].typeof}`;
     }
     jsonSchema(_parameters) {
         switch (this.primitiveIn.length) {
             case 0:
-                return code `${this.reusables.imports.z}.${this.typeofs[0]}()`;
+                return code `${this.reusables.imports.z}.${this.jsTypes[0].typeof}()`;
             case 1:
-                return code `${this.reusables.imports.z}.literal(${this.literalExpression(this.primitiveIn[0])})`;
+                return code `${this.reusables.imports.z}.literal(${this.literalValueExpression(this.primitiveIn[0])})`;
             default:
-                return code `${this.reusables.imports.z}.union([${joinCode(this.primitiveIn.map((value) => code `${this.reusables.imports.z}.literal(${this.literalExpression(value)})`), { on: "," })}])`;
+                return code `${this.reusables.imports.z}.union([${joinCode(this.primitiveIn.map((value) => code `${this.reusables.imports.z}.literal(${this.literalValueExpression(value)})`), { on: "," })}])`;
         }
     }
     toRdfResourceValuesExpression({ variables, }) {
-        return code `[${this.reusables.snippets.literalFactory}.${this.typeofs[0]}(${variables.value}, ${this.rdfjsTermExpression(this.datatype)})]`;
-    }
-    fromRdfResourceValuesExpressionChain({ variables, }) {
-        return {
-            ...super.fromRdfResourceValuesExpressionChain({ variables }),
-            languageIn: undefined,
-            preferredLanguages: undefined,
-            valueTo: code `chain(values => values.chainMap(value => ${this.fromRdfResourceValueExpression({
-                variables: { value: code `value` },
-            })}))`,
-        };
+        return code `[${this.reusables.snippets.literalFactory}.${this.jsTypes[0].typeof}(${variables.value}, ${this.rdfjsTermExpression(this.datatype)})]`;
     }
 }
 __decorate([
@@ -60,15 +50,15 @@ __decorate([
 __decorate([
     Memoize()
 ], AbstractNumericType.prototype, "filterType", null);
-__decorate([
-    Memoize()
-], AbstractNumericType.prototype, "expression", null);
 __decorate([
     Memoize()
 ], AbstractNumericType.prototype, "schemaType", null);
 __decorate([
     Memoize()
 ], AbstractNumericType.prototype, "valueSparqlWherePatternsFunction", null);
+__decorate([
+    Memoize()
+], AbstractNumericType.prototype, "inlineExpression", null);
 (function (AbstractNumericType) {
     AbstractNumericType.JsonType = AbstractPrimitiveType.JsonType;
 })(AbstractNumericType || (AbstractNumericType = {}));

package/dist/generators/ts/AbstractObjectSetType.d.ts

@@ -20,9 +20,9 @@ export declare abstract class AbstractObjectSetType {
     });
     abstract readonly declaration: Code;
     protected methodSignatures(namedObjectType: {
-        readonly alias: Maybe<string>;
         readonly filterType: Code;
         readonly identifierTypeAlias: Code;
+        readonly name: Maybe<string>;
         readonly objectSetMethodNames: ObjectType.ObjectSetMethodNames;
     }, options?: {
         parameterNamePrefix?: string;

package/dist/generators/ts/AbstractObjectSetType.js

@@ -21,7 +21,7 @@ export class AbstractObjectSetType {
             object: {
                 name: methodNames.object,
                 parameters: code `${parameterNamePrefix}identifier: ${namedObjectType.identifierTypeAlias}, options?: { preferredLanguages?: readonly string[]; }`,
-                returnType: code `Promise<${this.reusables.imports.Either}<Error, ${namedObjectType.alias.unsafeCoerce()}>>`,
+                returnType: code `Promise<${this.reusables.imports.Either}<Error, ${namedObjectType.name.unsafeCoerce()}>>`,
             },
             objectCount: {
                 name: methodNames.objectCount,
@@ -36,7 +36,7 @@ export class AbstractObjectSetType {
             objects: {
                 name: methodNames.objects,
                 parameters: code `${parameterNamePrefix}query?: ${queryT}<${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>`,
-                returnType: code `Promise<${this.reusables.imports.Either}<Error, readonly ${namedObjectType.alias.unsafeCoerce()}[]>>`,
+                returnType: code `Promise<${this.reusables.imports.Either}<Error, readonly ${namedObjectType.name.unsafeCoerce()}[]>>`,
             },
         };
     }

package/dist/generators/ts/AbstractPrimitiveType.d.ts

@@ -17,12 +17,13 @@ export declare abstract class AbstractPrimitiveType<ValueT extends bigint | bool
     fromJsonExpression({ variables, }: Parameters<AbstractLiteralType["fromJsonExpression"]>[0]): Code;
     graphqlResolveExpression({ variables, }: Parameters<AbstractLiteralType["graphqlResolveExpression"]>[0]): Code;
     jsonType(): AbstractLiteralType.JsonType;
-    abstract literalExpression(literal: Literal | ValueT): Code;
+    abstract literalValueExpression(literal: Literal | ValueT): Code;
     toJsonExpression({ variables, }: Parameters<AbstractLiteralType["toJsonExpression"]>[0]): Code;
 }
 export declare namespace AbstractPrimitiveType {
     type ConversionFunction = AbstractLiteralType.ConversionFunction;
     type DiscriminantProperty = AbstractLiteralType.DiscriminantProperty;
+    type JsType = AbstractLiteralType.JsType;
     const GraphqlType: typeof import("./AbstractType.js").AbstractType.GraphqlType;
     type GraphqlType = AbstractLiteralType.GraphqlType;
     const JsonType: typeof import("./AbstractType.js").AbstractType.JsonType;

package/dist/generators/ts/AbstractPrimitiveType.js

@@ -24,7 +24,7 @@ export class AbstractPrimitiveType extends AbstractLiteralType {
     get schemaInitializers() {
         let initializers = super.schemaInitializers;
         if (this.primitiveIn.length > 0) {
-            initializers = initializers.concat(code `in: ${arrayOf(...this.primitiveIn.map((in_) => this.literalExpression(in_)))}`);
+            initializers = initializers.concat(code `in: ${arrayOf(...this.primitiveIn.map((in_) => this.literalValueExpression(in_)))} as const`);
         }
         return initializers;
     }

package/dist/generators/ts/AbstractTermType.d.ts

@@ -2,11 +2,9 @@ import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
 import { NodeKind } from "@shaclmate/shacl-ast";
 import { Maybe } from "purify-ts";
 import { AbstractType } from "./AbstractType.js";
-import type { Type } from "./Type.js";
-import type { Typeof } from "./Typeof.js";
 import { type Code } from "./ts-poet-wrapper.js";
 /**
- * Abstract base class for IdentifierType and LiteralType.
+ * Abstract base class for all types that are terms in RDF (i.e., identifiers, literals).
  *
  * ConstantTermT is the type of sh:hasValue and sh:in.
  * RuntimeTermT is the type of values at runtime.
@@ -14,7 +12,7 @@ import { type Code } from "./ts-poet-wrapper.js";
  * The two are differentiated because identifiers can have BlankNode or NamedNode values at runtime but only NamedNode values for sh:hasValue and sh:in.
  */
 export declare abstract class AbstractTermType<ConstantTermT extends Literal | NamedNode = Literal | NamedNode, _RuntimeTermT extends BlankNode | Literal | NamedNode = BlankNode | Literal | NamedNode> extends AbstractType {
-    readonly declaration: Maybe<Code>;
+    protected abstract readonly inlineExpression: Code;
     readonly equalsFunction: Code;
     readonly graphqlArgs: AbstractType["graphqlArgs"];
     readonly hasValues: readonly ConstantTermT[];
@@ -23,43 +21,29 @@ export declare abstract class AbstractTermType<ConstantTermT extends Literal | N
     readonly mutable: boolean;
     abstract readonly nodeKinds: ReadonlySet<NodeKind>;
     readonly recursive = false;
-    readonly referencesObjectType = false;
-    readonly typeofs: readonly Typeof[];
     readonly validationFunction: Maybe<Code>;
     constructor({ hasValues, in_, ...superParameters }: {
         hasValues: readonly ConstantTermT[];
         in_: readonly ConstantTermT[];
     } & ConstructorParameters<typeof AbstractType>[0]);
-    get constrained(): boolean;
+    get declaration(): Maybe<Code>;
     get discriminantProperty(): Maybe<AbstractType.DiscriminantProperty>;
+    get expression(): Code;
+    get referencesNamedType(): boolean;
     get termTypes(): ReadonlySet<"BlankNode" | "Literal" | "NamedNode">;
     get toRdfResourceValueTypes(): Set<"BlankNode" | "Literal" | "NamedNode">;
     get valueSparqlConstructTriplesFunction(): Code;
-    fromRdfResourceValuesExpression(parameters: Parameters<AbstractType["fromRdfResourceValuesExpression"]>[0]): Code;
+    protected get schemaInitializers(): readonly Code[];
     jsonUiSchemaElement(): Maybe<Code>;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
     toStringExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
-    /**
-     * The fromRdfExpression for a term type can be decomposed into multiple sub-expressions with different purposes:
-     *
-     * hasValues: test whether the values sequence has sh:hasValue values
-     * languageIn: filter the values sequence to literals with the right sh:languageIn (or runtime languageIn)
-     * valueTo: convert values in the values sequence to the appropriate term type/sub-type (literal, string, etc.)
-     *
-     * Considering the sub-expressions as a record instead of an array allows them to be selectively overridden by subclasses.
-     */
-    protected fromRdfResourceValuesExpressionChain({ variables, }: Parameters<Type["fromRdfResourceValuesExpression"]>[0]): {
-        hasValues?: Code;
-        languageIn?: Code;
-        preferredLanguages?: Code;
-        valueTo: Code;
-    };
 }
 export declare namespace AbstractTermType {
     type ConversionFunction = AbstractType.ConversionFunction;
     type DiscriminantProperty = AbstractType.DiscriminantProperty;
     const GraphqlType: typeof AbstractType.GraphqlType;
     type GraphqlType = AbstractType.GraphqlType;
+    type JsType = AbstractType.JsType;
     const JsonType: typeof AbstractType.JsonType;
     type JsonType = AbstractType.JsonType;
 }

package/dist/generators/ts/AbstractTermType.js

@@ -8,9 +8,9 @@ import { NodeKind } from "@shaclmate/shacl-ast";
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractType } from "./AbstractType.js";
-import { code, joinCode } from "./ts-poet-wrapper.js";
+import { arrayOf, code } from "./ts-poet-wrapper.js";
 /**
- * Abstract base class for IdentifierType and LiteralType.
+ * Abstract base class for all types that are terms in RDF (i.e., identifiers, literals).
  *
  * ConstantTermT is the type of sh:hasValue and sh:in.
  * RuntimeTermT is the type of values at runtime.
@@ -18,7 +18,6 @@ import { code, joinCode } from "./ts-poet-wrapper.js";
  * The two are differentiated because identifiers can have BlankNode or NamedNode values at runtime but only NamedNode values for sh:hasValue and sh:in.
  */
 export class AbstractTermType extends AbstractType {
-    declaration = Maybe.empty();
     equalsFunction = code `${this.reusables.snippets.booleanEquals}`;
     graphqlArgs = Maybe.empty();
     hasValues;
@@ -26,26 +25,32 @@ export class AbstractTermType extends AbstractType {
     in_;
     mutable = false;
     recursive = false;
-    referencesObjectType = false;
-    typeofs = ["object"];
     validationFunction = Maybe.empty();
     constructor({ hasValues, in_, ...superParameters }) {
         super(superParameters);
         this.hasValues = hasValues;
         this.in_ = in_;
     }
-    get constrained() {
-        return this.hasValues.length > 0 || this.in_.length > 0;
+    get declaration() {
+        return this.name.map((name) => code `export type ${name} = ${this.inlineExpression};`);
     }
     get discriminantProperty() {
         return Maybe.of({
-            descendantValues: [],
             jsonName: "termType",
             name: "termType",
-            ownValues: [...this.nodeKinds].map(NodeKind.toTermType),
-            type: "string",
+            values: [...this.nodeKinds].map(NodeKind.toTermType),
         });
     }
+    get expression() {
+        const name = this.name.extract();
+        if (name) {
+            return code `${name}`;
+        }
+        return this.inlineExpression;
+    }
+    get referencesNamedType() {
+        return this.name.isJust();
+    }
     get termTypes() {
         return new Set([...this.nodeKinds].map(NodeKind.toTermType));
     }
@@ -55,21 +60,12 @@ export class AbstractTermType extends AbstractType {
     get valueSparqlConstructTriplesFunction() {
         return code `((_: object) => [])`;
     }
-    fromRdfResourceValuesExpression(parameters) {
-        // invariant(
-        //   this.nodeKinds.has("Literal") &&
-        //     (this.nodeKinds.has("BlankNode") || this.nodeKinds.has("NamedNode")),
-        //   "IdentifierType and LiteralType should override",
-        // );
-        const chain = this.fromRdfResourceValuesExpressionChain(parameters);
-        const { variables } = parameters;
-        return joinCode([
-            variables.resourceValues,
-            chain.hasValues,
-            chain.languageIn,
-            chain.preferredLanguages,
-            chain.valueTo,
-        ].filter((_) => _ !== undefined), { on: "." });
+    get schemaInitializers() {
+        let initializers = super.schemaInitializers;
+        if (this.hasValues.length > 0) {
+            initializers = initializers.concat(code `hasValues: ${arrayOf(...this.hasValues.map((hasValue) => this.rdfjsTermExpression(hasValue)))}`);
+        }
+        return initializers;
     }
     jsonUiSchemaElement() {
         return Maybe.empty();
@@ -80,43 +76,16 @@ export class AbstractTermType extends AbstractType {
     toStringExpression({ variables, }) {
         return code `${variables.value}.toString()`;
     }
-    /**
-     * The fromRdfExpression for a term type can be decomposed into multiple sub-expressions with different purposes:
-     *
-     * hasValues: test whether the values sequence has sh:hasValue values
-     * languageIn: filter the values sequence to literals with the right sh:languageIn (or runtime languageIn)
-     * valueTo: convert values in the values sequence to the appropriate term type/sub-type (literal, string, etc.)
-     *
-     * Considering the sub-expressions as a record instead of an array allows them to be selectively overridden by subclasses.
-     */
-    fromRdfResourceValuesExpressionChain({ variables, }) {
-        let valueToExpression;
-        if (this.in_.length > 0) {
-            valueToExpression = code `value.toTerm([${joinCode(this.in_.map((in_) => this.rdfjsTermExpression(in_)), { on: ", " })}])`;
-        }
-        else if (this.nodeKinds.size < 3) {
-            const eitherTypeParameters = code `<Error, ${this.expression}>`;
-            valueToExpression = code `value.toTerm().chain(term => {
-  switch (term.termType) {
-  ${[...this.nodeKinds].map((nodeKind) => `case "${NodeKind.toTermType(nodeKind)}":`).join("\n")} return ${this.reusables.imports.Either}.of${eitherTypeParameters}(term);
-  default: return ${this.reusables.imports.Left}${eitherTypeParameters}(new ${this.reusables.imports.Resource}.MistypedTermValueError(${{ actualValue: code `term`, expectedValueType: code `${this.expression}`.toCodeString([]), focusResource: variables.resource, propertyPath: variables.propertyPath }}));
-  }})`;
-        }
-        else {
-            valueToExpression = code `value.toTerm()`;
-        }
-        return {
-            hasValues: this.hasValues.length > 0
-                ? code `\
-chain(values => ${this.reusables.imports.Either}.sequence([${joinCode(this.hasValues.map((hasValue) => this.rdfjsTermExpression(hasValue)), { on: ", " })}].map(hasValue => values.find(value => value.term.equals(hasValue)))).map(() => values))`
-                : undefined,
-            valueTo: code `chain(values => values.chainMap(value => ${valueToExpression}))`,
-        };
-    }
 }
+__decorate([
+    Memoize()
+], AbstractTermType.prototype, "declaration", null);
 __decorate([
     Memoize()
 ], AbstractTermType.prototype, "discriminantProperty", null);
+__decorate([
+    Memoize()
+], AbstractTermType.prototype, "expression", null);
 __decorate([
     Memoize()
 ], AbstractTermType.prototype, "termTypes", null);

package/dist/generators/ts/AbstractType.d.ts

@@ -1,9 +1,9 @@
+import type { BlankNode, NamedNode } from "@rdfjs/types";
 import type { Maybe } from "purify-ts";
 import type { Logger } from "ts-log";
 import type { Reusables } from "./Reusables.js";
 import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
 import type { TsGenerator } from "./TsGenerator.js";
-import type { Typeof } from "./Typeof.js";
 import { type Code } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class all types.
@@ -12,10 +12,6 @@ export declare abstract class AbstractType {
     protected readonly configuration: TsGenerator.Configuration;
     protected readonly logger: Logger;
     protected readonly reusables: Reusables;
-    /**
-     * Alias for this type.
-     */
-    readonly alias: Maybe<string>;
     /**
      * Comment from rdfs:comment.
      */
@@ -39,7 +35,7 @@ export declare abstract class AbstractType {
      */
     abstract readonly discriminantProperty: Maybe<AbstractType.DiscriminantProperty>;
     /**
-     * A function (reference or declaration) that compares two property values of this type, returning a
+     * A function (reference or literal) that compares two property values of this type, returning a
      * $EqualsResult.
      */
     abstract readonly equalsFunction: Code;
@@ -48,7 +44,7 @@ export declare abstract class AbstractType {
      */
     abstract readonly expression: Code;
     /**
-     * A function (reference or declaration) that takes a filter of filterType (below) and a value of this type
+     * A function (reference or literal) that takes a filter of filterType (below) and a value of this type
      * and returns true if the value passes the filter.
      */
     abstract readonly filterFunction: Code;
@@ -56,6 +52,27 @@ export declare abstract class AbstractType {
      * Composite type for filtering instances of this type e.g., SomeObject.Filter with filters for each property.
      */
     abstract readonly filterType: Code;
+    /**
+     * A FromRdfResourceValuesFunction (reference or literal) that converts a Either<Error, rdfjsResource.Resource.Values> to a
+     * Either<Error, rdfjsResource.Resource.Values<this type>>.
+     *
+     * These functions are used to deserialize property values in an ObjectType, either directly (a property with this type) or indirectly (a property with a type like OptionType
+     * that has a type parameter of this 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. Similarly, values may also need to be sorted. For example, specifying preferredLanguages should sort the values in the order of the specified languages so that the first value
+     * (if it exists) is always of the first preferred language.
+     *
+     * The function takes two parameters, a rdfjsResource.Resource.Values and a parameters object with the following parameters:
+     *   context: unanticipated properties (...) passed to Object.fromRdf
+     *   focusResource: the Resource passed to Object.fromRdf
+     *   graph: DefaultGraph | NamedNode | undefined to match (subject, predicate, object) triples in; if undefined, match triples in all graphs
+     *   ignoreRdfType: whether the RDF type of objects/object unions should be ignored
+     *   objectSet: the ObjectSet passed to Object.fromRdf
+     *   preferredLanguages: the preferred languages array (e.g., ["en"]) passed to Object.fromRdf
+     *   propertyPath: the PropertyPath of the object's property
+     */
+    abstract readonly fromRdfResourceValuesFunction: Code;
     /**
      * Declarations for GraphQL arguments to pass to this the graphqlResolveExpression.
      */
@@ -67,9 +84,13 @@ export declare abstract class AbstractType {
      */
     abstract readonly graphqlType: AbstractType.GraphqlType;
     /**
-     * A function (reference or declaration) that takes a  Hasher and a value of this type, calls hasher.update on the value, and returns the Hasher.
+     * A function (reference or literal) that takes a  Hasher and a value of this type, calls hasher.update on the value, and returns the Hasher.
      */
     abstract readonly hashFunction: Code;
+    /**
+     * JavaScript type(s) the type.
+     */
+    abstract readonly jsTypes: readonly AbstractType.JsType[];
     /**
      * Type discriminant.
      */
@@ -82,6 +103,10 @@ export declare abstract class AbstractType {
      * Is a value of this type mutable?
      */
     abstract readonly mutable: boolean;
+    /**
+     * Name for this type.
+     */
+    readonly name: Maybe<string>;
     /**
      * Does this type directly or indirectly reference itself?
      */
@@ -89,19 +114,19 @@ export declare abstract class AbstractType {
     /**
      * Is this type an ObjectType or does it reference an object type?
      */
-    abstract readonly referencesObjectType: boolean;
+    abstract readonly referencesNamedType: boolean;
     /**
      * TypeScript type describing .schema.
      */
     abstract readonly schemaType: Code;
     /**
-     * The type(s) of the array elements produced by the toRdfResourceValuesExpression.
+     * Identifier of the shape this type was derived from.
      */
-    abstract readonly toRdfResourceValueTypes: ReadonlySet<"BlankNode" | "NamedNode" | "Literal">;
+    readonly shapeIdentifier: BlankNode | NamedNode;
     /**
-     * JavaScript typeof(s) the type.
+     * The type(s) of the array elements produced by the toRdfResourceValuesExpression.
      */
-    abstract readonly typeofs: readonly Typeof[];
+    abstract readonly toRdfResourceValueTypes: ReadonlySet<"BlankNode" | "NamedNode" | "Literal">;
     /**
      * Function that takes
      * - a schema of this.schemaType
@@ -115,7 +140,7 @@ export declare abstract class AbstractType {
      */
     abstract readonly validationFunction: Maybe<Code>;
     /**
-     * A ValueSparqlConstructTriplesFunction (reference or declaration) that returns an array of sparqljs.Triple's for a property value of this type.
+     * A ValueSparqlConstructTriplesFunction (reference or literal) that returns an array of sparqljs.Triple's for a property value of this type.
      *
      * The function takes a parameters object with the following parameters:
      * - filter: an instance of filterType | undefined
@@ -126,7 +151,7 @@ export declare abstract class AbstractType {
      */
     abstract readonly valueSparqlConstructTriplesFunction: Code;
     /**
-     * A ValueSparqlWherePatternsFunction (reference or declaration) that returns an array of SparqlPattern's for a property value of this type.
+     * A ValueSparqlWherePatternsFunction (reference or literal) that returns an array of SparqlPattern's for a property value of this type.
      *
      * The function takes a parameters object with the following parameters:
      * - filter: an instance of filterType | undefined
@@ -137,18 +162,20 @@ export declare abstract class AbstractType {
      * - variablePrefix: string prefix to use for new variables
      */
     abstract readonly valueSparqlWherePatternsFunction: Code;
-    constructor({ alias, comment, configuration, label, logger, reusables, }: {
-        alias: Maybe<string>;
+    constructor({ comment, configuration, label, logger, name, reusables, shapeIdentifier, }: {
+        name: Maybe<string>;
         comment: Maybe<string>;
         configuration: TsGenerator.Configuration;
         label: Maybe<string>;
         logger: Logger;
         reusables: Reusables;
+        shapeIdentifier: BlankNode | NamedNode;
     });
     /**
      * TypeScript object describing this type, for runtime use.
      */
     get schema(): Code;
+    protected get schemaExpression(): Code;
     /**
      * Helper to compose the result of schema along the type hierarchy.
      */
@@ -161,41 +188,6 @@ export declare abstract class AbstractType {
             value: Code;
         };
     }): Code;
-    /**
-     * An expression that converts a Either<Error, rdfjsResource.Resource.Values> to a
-     * Either<Error, rdfjsResource.Resource.Values<this type>>.
-     *
-     * These expressions are used to deserialize property values in an ObjectType, either directly (a property with this Type) or indirectly (a property with a Type like OptionType
-     * that has a type parameter of this 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, specifying preferredLanguages should sort the values in the order of the specified languages so that the first value
-     * (if it exists) is always of the first preferred language.
-     *
-     * variables are runtime variables, most derived from the parameters of the ObjectType's fromRdf function:
-     *   context: unanticipated properties (...) passed to Object.fromRdf
-     *   graph: DefaultGraph | NamedNode | undefined to match (subject, predicate, object) triples in; if undefined, match triples in all graphs
-     *   ignoreRdfType: whether the RDF type of objects/object unions should be ignored
-     *   objectSet: the ObjectSet passed to Object.fromRdf
-     *   preferredLanguages: the preferred languages array (e.g., ["en"]) passed to Object.fromRdf
-     *   propertyPath: the PropertyPath of the object's property
-     *   resource: the Resource passed to Object.fromRdf
-     *   resourceValues: the Either<Error, rdfjsResource.Resource.Values> to be converted to values of this type
-     */
-    abstract fromRdfResourceValuesExpression(parameters: {
-        variables: {
-            context: Code;
-            graph: Code;
-            ignoreRdfType?: boolean;
-            objectSet: Code;
-            preferredLanguages: Code;
-            propertyPath: Code;
-            resource: Code;
-            resourceValues: Code;
-        };
-    }): Code;
     /**
      * An expression that resolves a value of this type in the GraphQL server.
      */
@@ -277,14 +269,13 @@ export declare namespace AbstractType {
         readonly code: Code;
         readonly sourceTypes: {
             readonly expression: Code;
-            readonly typeof: Typeof;
+            readonly jsType: JsType;
         }[];
     }
     interface DiscriminantProperty {
-        readonly descendantValues: readonly DiscriminantProperty.Value[];
         readonly jsonName: string;
         readonly name: string;
-        readonly ownValues: readonly DiscriminantProperty.Value[];
+        readonly values: readonly DiscriminantProperty.Value[];
     }
     namespace DiscriminantProperty {
         type Value = number | string;
@@ -295,14 +286,46 @@ export declare namespace AbstractType {
          */
         readonly nullable: boolean;
         /**
-         * The name of the type when it's nullable -- so it should never include "new graphql.GraphQLNonNull(...)" around it.
+         * The expression of the type when it's nullable -- so it should never include "new graphql.GraphQLNonNull(...)" around it.
          */
-        readonly nullableName: Code;
+        readonly nullableExpression: Code;
         private readonly reusables;
-        constructor(nullableName: Code, reusables: Reusables, options?: {
+        constructor(nullableExpression: Code, reusables: Reusables, options?: {
             nullable: boolean;
         });
-        get name(): Code;
+        get expression(): Code;
+    }
+    type JsType = {
+        typeof: "bigint";
+    } | {
+        typeof: "boolean";
+    } | {
+        typeof: "function";
+    } | {
+        typeof: "number";
+    } | {
+        instanceof: "Array";
+        typeof: "object";
+    } | {
+        className: Code;
+        instanceof: "class";
+        typeof: "object";
+    } | {
+        instanceof: "Date";
+        typeof: "object";
+    } | {
+        instanceof: "Maybe";
+        typeof: "object";
+    } | {
+        instanceof: "Object";
+        typeof: "object";
+    } | {
+        typeof: "string";
+    } | {
+        typeof: "undefined";
+    };
+    namespace JsType {
+        function equals(left: JsType, right: JsType): boolean;
     }
     class JsonType {
         /**
@@ -310,13 +333,13 @@ export declare namespace AbstractType {
          */
         readonly optional: boolean;
         /**
-         * The name of the type when it's required i.e. -- so it should never include "| undefined".
+         * The expression of the type when it's required i.e. -- so it should never include "| undefined".
          */
-        readonly requiredName: Code | string;
-        constructor(requiredName: Code | string, parameters?: {
+        readonly requiredExpression: Code;
+        constructor(requiredExpression: Code, parameters?: {
             optional: boolean;
         });
-        get name(): Code | string;
+        get expression(): Code;
     }
 }
 //# sourceMappingURL=AbstractType.d.ts.map