@shaclmate/compiler 4.0.39 → 4.0.40

package/dist/generators/ts/AbstractCollectionType.d.ts

@@ -17,12 +17,12 @@ export declare abstract class AbstractCollectionType<ItemTypeT extends AbstractC
     } & ConstructorParameters<typeof AbstractContainerType<ItemTypeT>>[0]);
     get conversionFunction(): Maybe<AbstractType.ConversionFunction>;
     get equalsFunction(): Code;
+    get expression(): Code;
     get filterFunction(): Code;
     get filterType(): Code;
     get graphqlType(): AbstractContainerType.GraphqlType;
     get hashFunction(): Code;
     get mutable(): boolean;
-    get name(): Code;
     get schemaType(): Code;
     get validationFunction(): Maybe<Code>;
     protected get schemaInitializers(): readonly Code[];

package/dist/generators/ts/AbstractCollectionType.js

@@ -31,13 +31,13 @@ export class AbstractCollectionType extends AbstractContainerType {
         const itemConversionFunction = this.itemType.conversionFunction.orDefault(this.itemConversionFunctionDefault);
         const sourceTypes = [
             {
-                name: code `readonly (${joinCode(itemConversionFunction.sourceTypes.map((itemSourceType) => code `${itemSourceType.name}`), { on: " | " })})[]`,
+                expression: code `readonly (${joinCode(itemConversionFunction.sourceTypes.map((itemSourceType) => code `${itemSourceType.expression}`), { on: " | " })})[]`,
                 typeof: "object",
             },
         ];
         if (this.minCount === 0n) {
             sourceTypes.push({
-                name: "undefined",
+                expression: code `undefined`,
                 typeof: "undefined",
             });
         }
@@ -49,8 +49,11 @@ export class AbstractCollectionType extends AbstractContainerType {
     get equalsFunction() {
         return code `((left, right) => ${this.reusables.snippets.arrayEquals}(left, right, ${this.itemType.equalsFunction}))`;
     }
+    get expression() {
+        return code `${!this._mutable ? "readonly " : ""}(${this.itemType.expression})[]`;
+    }
     get filterFunction() {
-        return code `${this.reusables.snippets.filterArray}<${this.itemType.name}, ${this.itemType.filterType}>(${this.itemType.filterFunction})`;
+        return code `${this.reusables.snippets.filterArray}<${this.itemType.expression}, ${this.itemType.filterType}>(${this.itemType.filterFunction})`;
     }
     get filterType() {
         return code `${this.reusables.snippets.CollectionFilter}<${this.itemType.filterType}>`;
@@ -64,9 +67,6 @@ export class AbstractCollectionType extends AbstractContainerType {
     get mutable() {
         return this._mutable || this.itemType.mutable;
     }
-    get name() {
-        return code `${!this._mutable ? "readonly " : ""}(${this.itemType.name})[]`;
-    }
     get schemaType() {
         return code `${this.reusables.snippets.CollectionSchema}<${this.itemType.schemaType}>`;
     }
@@ -85,7 +85,7 @@ export class AbstractCollectionType extends AbstractContainerType {
         if (this.minCount === 0n) {
             expression = code `(${expression} ?? [])`;
         }
-        return code `${this.reusables.imports.Either}.sequence<Error, ${this.itemType.name}>(${expression}.map(item => (${this.itemType.fromJsonExpression({
+        return code `${this.reusables.imports.Either}.sequence<Error, ${this.itemType.expression}>(${expression}.map(item => (${this.itemType.fromJsonExpression({
             variables: { value: code `item` },
         })})))`;
     }
@@ -118,6 +118,9 @@ __decorate([
 __decorate([
     Memoize()
 ], AbstractCollectionType.prototype, "equalsFunction", null);
+__decorate([
+    Memoize()
+], AbstractCollectionType.prototype, "expression", null);
 __decorate([
     Memoize()
 ], AbstractCollectionType.prototype, "filterFunction", null);
@@ -130,9 +133,6 @@ __decorate([
 __decorate([
     Memoize()
 ], AbstractCollectionType.prototype, "hashFunction", null);
-__decorate([
-    Memoize()
-], AbstractCollectionType.prototype, "name", null);
 __decorate([
     Memoize()
 ], AbstractCollectionType.prototype, "schemaType", null);

package/dist/generators/ts/AbstractContainerType.d.ts

@@ -1,6 +1,5 @@
 import { Maybe } from "purify-ts";
 import { AbstractType } from "./AbstractType.js";
-import type { AnonymousUnionType } from "./AnonymousUnionType.js";
 import type { BigDecimalType } from "./BigDecimalType.js";
 import type { BigIntType } from "./BigIntType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
@@ -13,13 +12,13 @@ import type { IntType } from "./IntType.js";
 import type { IriType } from "./IriType.js";
 import type { ListType } from "./ListType.js";
 import type { LiteralType } from "./LiteralType.js";
-import type { NamedObjectType } from "./NamedObjectType.js";
-import type { NamedObjectUnionType } from "./NamedObjectUnionType.js";
-import type { NamedUnionType } from "./NamedUnionType.js";
+import type { ObjectType } from "./ObjectType.js";
+import type { ObjectUnionType } from "./ObjectUnionType.js";
 import type { StringType } from "./StringType.js";
 import type { TermType } from "./TermType.js";
 import type { Type } from "./Type.js";
 import { type Code } from "./ts-poet-wrapper.js";
+import type { UnionType } from "./UnionType.js";
 /**
  * Abstract base class for types that contain other types e.g., ListType, OptionType, SetType.
  */
@@ -47,7 +46,7 @@ export declare namespace AbstractContainerType {
     type DiscriminantProperty = AbstractType.DiscriminantProperty;
     const GraphqlType: typeof AbstractType.GraphqlType;
     type GraphqlType = AbstractType.GraphqlType;
-    type ItemType = AnonymousUnionType | BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | FloatType | IdentifierType | IntType | IriType | ListType<ListType.ItemType> | LiteralType | NamedObjectUnionType | NamedUnionType | NamedObjectType | StringType | TermType;
+    type ItemType = BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | FloatType | IdentifierType | IntType | IriType | ListType<ListType.ItemType> | LiteralType | ObjectUnionType | ObjectType | StringType | TermType | UnionType<Type>;
     function isItemType(type: Type): type is ItemType;
     const JsonType: typeof AbstractType.JsonType;
     type JsonType = AbstractType.JsonType;

package/dist/generators/ts/AbstractContainerType.js

@@ -37,7 +37,7 @@ export class AbstractContainerType extends AbstractType {
             code: code `${this.reusables.snippets.identityConversionFunction}`,
             sourceTypes: [
                 {
-                    name: this.itemType.name,
+                    expression: this.itemType.expression,
                     typeof: this.itemType.typeofs[0],
                 },
             ],
@@ -67,7 +67,6 @@ __decorate([
     AbstractContainerType.GraphqlType = AbstractType.GraphqlType;
     function isItemType(type) {
         switch (type.kind) {
-            case "AnonymousUnion":
             case "BigDecimal":
             case "BigInt":
             case "BlankNode":
@@ -80,11 +79,11 @@ __decorate([
             case "Iri":
             case "List":
             case "Literal":
-            case "NamedObjectUnion":
-            case "NamedUnion":
-            case "NamedObjectType":
+            case "Object":
+            case "ObjectUnion":
             case "String":
             case "Term":
+            case "Union":
                 return true;
             case "DefaultValue":
             case "LazyObjectOption":

package/dist/generators/ts/AbstractDateType.d.ts

@@ -2,23 +2,23 @@ import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare abstract class AbstractDateType extends AbstractPrimitiveType<Date> {
     readonly equalsFunction: Code;
+    readonly expression: Code;
     readonly filterFunction: Code;
     readonly filterType: Code;
     abstract readonly kind: "DateTime" | "Date";
     readonly mutable = false;
-    readonly name = "Date";
     readonly schemaType: Code;
-    readonly valueSparqlWherePatternsFunction: Code;
     readonly typeofs: "object"[];
+    readonly valueSparqlWherePatternsFunction: Code;
     fromJsonExpression({ variables, }: Parameters<AbstractPrimitiveType<Date>["fromJsonExpression"]>[0]): Code;
     jsonType(): AbstractPrimitiveType.JsonType;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<Date>["toRdfResourceValuesExpression"]>[0]): Code;
-    protected fromRdfResourceValuesExpressionChain({ variables, }: Parameters<AbstractPrimitiveType<Date>["fromRdfResourceValuesExpressionChain"]>[0]): ReturnType<AbstractPrimitiveType<Date>["fromRdfResourceValuesExpressionChain"]>;
     protected abstract fromRdfResourceValueExpression(variables: {
         variables: {
             value: Code;
         };
     }): Code;
+    protected fromRdfResourceValuesExpressionChain({ variables, }: Parameters<AbstractPrimitiveType<Date>["fromRdfResourceValuesExpressionChain"]>[0]): ReturnType<AbstractPrimitiveType<Date>["fromRdfResourceValuesExpressionChain"]>;
 }
 export declare namespace AbstractDateType {
     type ConversionFunction = AbstractPrimitiveType.ConversionFunction;

package/dist/generators/ts/AbstractDateType.js

@@ -9,13 +9,13 @@ import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
 import { code } from "./ts-poet-wrapper.js";
 export class AbstractDateType extends AbstractPrimitiveType {
     equalsFunction = code `${this.reusables.snippets.dateEquals}`;
+    expression = code `Date`;
     filterFunction = code `${this.reusables.snippets.filterDate}`;
     filterType = code `${this.reusables.snippets.DateFilter}`;
     mutable = false;
-    name = "Date";
     schemaType = code `${this.reusables.snippets.DateSchema}`;
-    valueSparqlWherePatternsFunction = code `${this.reusables.snippets.dateSparqlWherePatterns}`;
     typeofs = ["object"];
+    valueSparqlWherePatternsFunction = code `${this.reusables.snippets.dateSparqlWherePatterns}`;
     fromJsonExpression({ variables, }) {
         return code `${this.reusables.imports.Either}.of<Error, Date>(new Date(${variables.value}))`;
     }

package/dist/generators/ts/AbstractLazyObjectType.d.ts

@@ -1,7 +1,7 @@
 import { Maybe } from "purify-ts";
 import { AbstractType } from "./AbstractType.js";
-import type { NamedObjectType } from "./NamedObjectType.js";
-import type { NamedObjectUnionType } from "./NamedObjectUnionType.js";
+import type { ObjectType } from "./ObjectType.js";
+import type { ObjectUnionType } from "./ObjectUnionType.js";
 import type { OptionType } from "./OptionType.js";
 import type { SetType } from "./SetType.js";
 import { type Code } from "./ts-poet-wrapper.js";
@@ -24,17 +24,17 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
         resolveType: ResolveTypeT;
     } & ConstructorParameters<typeof AbstractType>[0]);
     get equalsFunction(): Code;
+    get expression(): Code;
     get filterFunction(): Code;
     get filterType(): Code;
     get graphqlType(): AbstractType.GraphqlType;
     get hashFunction(): Code;
-    get name(): Code;
     get recursive(): boolean;
-    protected get schemaInitializers(): readonly Code[];
     get schemaType(): Code;
     get toRdfResourceValueTypes(): AbstractType["toRdfResourceValueTypes"];
     get valueSparqlConstructTriplesFunction(): Code;
     get valueSparqlWherePatternsFunction(): Code;
+    protected get schemaInitializers(): readonly Code[];
     jsonSchema(parameters: Parameters<AbstractType["jsonSchema"]>[0]): Code;
     jsonType(parameters?: Parameters<AbstractType["jsonType"]>[0]): AbstractType.JsonType;
     jsonUiSchemaElement(parameters: Parameters<AbstractType["jsonUiSchemaElement"]>[0]): Maybe<Code>;
@@ -45,16 +45,16 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
         partialType: ObjectTypeT;
         resolveType: ObjectTypeT;
     }): Code;
-    protected resolvedNamedObjectUnionTypeToPartialNamedObjectUnionTypeConversion({ resolvedNamedObjectUnionType, partialNamedObjectUnionType, variables, }: {
-        resolvedNamedObjectUnionType: NamedObjectUnionType;
-        partialNamedObjectUnionType: NamedObjectUnionType;
+    protected resolvedObjectUnionTypeToPartialObjectUnionTypeConversion({ resolvedObjectUnionType, partialObjectUnionType, variables, }: {
+        resolvedObjectUnionType: ObjectUnionType;
+        partialObjectUnionType: ObjectUnionType;
         variables: {
             resolvedObjectUnion: Code;
         };
     }): Code;
 }
 export declare namespace AbstractLazyObjectType {
-    type ObjectTypeConstraint = NamedObjectType | NamedObjectUnionType;
+    type ObjectTypeConstraint = ObjectType | ObjectUnionType;
     type PartialTypeConstraint = ObjectTypeConstraint | OptionType<ObjectTypeConstraint> | SetType<ObjectTypeConstraint>;
     type ResolveTypeConstraint = PartialTypeConstraint;
     type ConversionFunction = AbstractType.ConversionFunction;

package/dist/generators/ts/AbstractLazyObjectType.js

@@ -26,8 +26,11 @@ export class AbstractLazyObjectType extends AbstractType {
     get equalsFunction() {
         return code `((left, right) => ${this.partialType.equalsFunction}(left.${this.runtimeClass.partialPropertyName}, right.${this.runtimeClass.partialPropertyName}))`;
     }
+    get expression() {
+        return this.runtimeClass.name;
+    }
     get filterFunction() {
-        return code `((filter: ${this.filterType}, value: ${this.name}) => ${this.partialType.filterFunction}(filter, value.${this.runtimeClass.partialPropertyName}))`;
+        return code `((filter: ${this.filterType}, value: ${this.expression}) => ${this.partialType.filterFunction}(filter, value.${this.runtimeClass.partialPropertyName}))`;
     }
     get filterType() {
         return this.partialType.filterType;
@@ -38,15 +41,9 @@ export class AbstractLazyObjectType extends AbstractType {
     get hashFunction() {
         return code `((hasher, value) => ${this.partialType.hashFunction}(hasher, value.${this.runtimeClass.partialPropertyName}))`;
     }
-    get name() {
-        return this.runtimeClass.name;
-    }
     get recursive() {
         return this.partialType.recursive;
     }
-    get schemaInitializers() {
-        return super.schemaInitializers.concat(code `get partialType() { return ${this.partialType.schema}; }`);
-    }
     get schemaType() {
         return code `${{
             kind: this.kind,
@@ -62,6 +59,9 @@ export class AbstractLazyObjectType extends AbstractType {
     get valueSparqlWherePatternsFunction() {
         return code `(({ schema, ...otherParameters }) => ${this.partialType.valueSparqlWherePatternsFunction}({ ...otherParameters, schema: schema.partialType }))`;
     }
+    get schemaInitializers() {
+        return super.schemaInitializers.concat(code `get partialType() { return ${this.partialType.schema}; }`);
+    }
     jsonSchema(parameters) {
         return this.partialType.jsonSchema(parameters);
     }
@@ -94,26 +94,26 @@ export class AbstractLazyObjectType extends AbstractType {
         });
     }
     resolveToPartialFunction({ partialType, resolveType, }) {
-        if (partialType.kind === "NamedObjectType") {
-            return code `${partialType.name}.createUnsafe`;
+        if (partialType.kind === "Object") {
+            return code `${partialType.alias.unsafeCoerce()}.createUnsafe`;
         }
-        invariant(partialType.kind === "NamedObjectUnion");
-        invariant(resolveType.kind === "NamedObjectUnion");
+        invariant(partialType.kind === "ObjectUnion");
+        invariant(resolveType.kind === "ObjectUnion");
         invariant(partialType.members.length === resolveType.members.length);
         const caseBlocks = resolveType.members.map(({ discriminantValues }, memberI) => {
-            return code `${discriminantValues.map((discriminantPropertyValue) => `case "${discriminantPropertyValue}":`).join("\n")} return ${partialType.members[memberI].type.name}.createUnsafe(resolved);`;
+            return code `${discriminantValues.map((discriminantPropertyValue) => `case "${discriminantPropertyValue}":`).join("\n")} return ${partialType.members[memberI].type.alias.unsafeCoerce()}.createUnsafe(resolved);`;
         });
         caseBlocks.push(code `default: resolved satisfies never; throw new Error("unrecognized type");`);
-        return code `((resolved: ${resolveType.name}) => { switch (resolved.${resolveType.discriminantProperty.unsafeCoerce().name}) { ${joinCode(caseBlocks)} } })`;
+        return code `((resolved: ${resolveType.expression}) => { switch (resolved.${resolveType.discriminantProperty.unsafeCoerce().name}) { ${joinCode(caseBlocks)} } })`;
     }
-    resolvedNamedObjectUnionTypeToPartialNamedObjectUnionTypeConversion({ resolvedNamedObjectUnionType, partialNamedObjectUnionType, variables, }) {
-        invariant(resolvedNamedObjectUnionType.members.length ===
-            partialNamedObjectUnionType.members.length);
-        const caseBlocks = resolvedNamedObjectUnionType.members.map(({ discriminantValues }, memberI) => {
-            return code `${discriminantValues.map((discriminantPropertyValue) => `case "${discriminantPropertyValue}":`).join("\n")} return ${partialNamedObjectUnionType.members[memberI].type.name}.create(${variables.resolvedObjectUnion});`;
+    resolvedObjectUnionTypeToPartialObjectUnionTypeConversion({ resolvedObjectUnionType, partialObjectUnionType, variables, }) {
+        invariant(resolvedObjectUnionType.members.length ===
+            partialObjectUnionType.members.length);
+        const caseBlocks = resolvedObjectUnionType.members.map(({ discriminantValues }, memberI) => {
+            return code `${discriminantValues.map((discriminantPropertyValue) => `case "${discriminantPropertyValue}":`).join("\n")} return ${partialObjectUnionType.members[memberI].type.alias.unsafeCoerce()}.create(${variables.resolvedObjectUnion});`;
         });
         caseBlocks.push(code `default: ${variables.resolvedObjectUnion} satisfies never; throw new Error("unrecognized type");`);
-        return code `switch (${variables.resolvedObjectUnion}.${resolvedNamedObjectUnionType.discriminantProperty.unsafeCoerce().name}) { ${joinCode(caseBlocks)} }`;
+        return code `switch (${variables.resolvedObjectUnion}.${resolvedObjectUnionType.discriminantProperty.unsafeCoerce().name}) { ${joinCode(caseBlocks)} }`;
     }
 }
 __decorate([

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

@@ -8,7 +8,7 @@ export declare abstract class AbstractNumericType<ValueT extends bigint | number
     abstract readonly kind: "BigInt" | "Float" | "Int";
     get filterFunction(): Code;
     get filterType(): Code;
-    get name(): Code | string;
+    get expression(): Code;
     get schemaType(): Code;
     get valueSparqlWherePatternsFunction(): Code;
     jsonSchema(_parameters: Parameters<AbstractPrimitiveType<ValueT>["jsonSchema"]>[0]): Code;

package/dist/generators/ts/AbstractNumericType.js

@@ -18,11 +18,11 @@ export class AbstractNumericType extends AbstractPrimitiveType {
     get filterType() {
         return code `${this.reusables.snippets.NumericFilter}<${this.typeofs[0]}>`;
     }
-    get name() {
+    get expression() {
         if (this.primitiveIn.length > 0) {
             return code `${joinCode(this.primitiveIn.map((value) => this.literalExpression(value)), { on: " | " })}`;
         }
-        return this.typeofs[0];
+        return code `${this.typeofs[0]}`;
     }
     get schemaType() {
         return code `${this.reusables.snippets.NumericSchema}<${this.typeofs[0]}>`;
@@ -62,7 +62,7 @@ __decorate([
 ], AbstractNumericType.prototype, "filterType", null);
 __decorate([
     Memoize()
-], AbstractNumericType.prototype, "name", null);
+], AbstractNumericType.prototype, "expression", null);
 __decorate([
     Memoize()
 ], AbstractNumericType.prototype, "schemaType", null);

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

@@ -1,6 +1,7 @@
+import type { Maybe } from "purify-ts";
 import type { Logger } from "ts-log";
-import type { NamedObjectType } from "./NamedObjectType.js";
-import type { NamedObjectUnionType } from "./NamedObjectUnionType.js";
+import type { ObjectType } from "./ObjectType.js";
+import type { ObjectUnionType } from "./ObjectUnionType.js";
 import type { Reusables } from "./Reusables.js";
 import type { TsGenerator } from "./TsGenerator.js";
 import { type Code } from "./ts-poet-wrapper.js";
@@ -8,25 +9,25 @@ export declare abstract class AbstractObjectSetType {
     protected readonly configuration: TsGenerator.Configuration;
     protected readonly logger: Logger;
     protected readonly reusables: Reusables;
-    protected readonly namedObjectTypes: readonly NamedObjectType[];
-    protected readonly namedObjectUnionTypes: readonly NamedObjectUnionType[];
+    protected readonly namedObjectTypes: readonly ObjectType[];
+    protected readonly namedObjectUnionTypes: readonly ObjectUnionType[];
     constructor({ configuration, logger, namedObjectTypes, namedObjectUnionTypes, reusables, }: {
         configuration: TsGenerator.Configuration;
         logger: Logger;
-        namedObjectTypes: readonly NamedObjectType[];
-        namedObjectUnionTypes: readonly NamedObjectUnionType[];
+        namedObjectTypes: readonly ObjectType[];
+        namedObjectUnionTypes: readonly ObjectUnionType[];
         reusables: Reusables;
     });
     abstract readonly declaration: Code;
     protected methodSignatures(namedObjectType: {
+        readonly alias: Maybe<string>;
         readonly filterType: Code;
         readonly identifierTypeAlias: Code;
-        readonly objectSetMethodNames: NamedObjectType.ObjectSetMethodNames;
-        readonly name: string;
+        readonly objectSetMethodNames: ObjectType.ObjectSetMethodNames;
     }, options?: {
         parameterNamePrefix?: string;
         queryT?: string;
-    }): Readonly<Record<keyof NamedObjectType.ObjectSetMethodNames, {
+    }): Readonly<Record<keyof ObjectType.ObjectSetMethodNames, {
         readonly name: string;
         readonly parameters: Code;
         readonly returnType: Code;

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.name}>>`,
+                returnType: code `Promise<${this.reusables.imports.Either}<Error, ${namedObjectType.alias.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.name}[]>>`,
+                returnType: code `Promise<${this.reusables.imports.Either}<Error, readonly ${namedObjectType.alias.unsafeCoerce()}[]>>`,
             },
         };
     }

package/dist/generators/ts/AbstractPrimitiveType.js

@@ -29,13 +29,13 @@ export class AbstractPrimitiveType extends AbstractLiteralType {
         return initializers;
     }
     fromJsonExpression({ variables, }) {
-        return code `${this.reusables.imports.Either}.of<Error, ${this.name}>(${variables.value})`;
+        return code `${this.reusables.imports.Either}.of<Error, ${this.expression}>(${variables.value})`;
     }
     graphqlResolveExpression({ variables, }) {
         return variables.value;
     }
     jsonType() {
-        return new AbstractLiteralType.JsonType(this.name);
+        return new AbstractLiteralType.JsonType(this.expression);
     }
     toJsonExpression({ variables, }) {
         return variables.value;

package/dist/generators/ts/AbstractTermType.js

@@ -95,11 +95,11 @@ export class AbstractTermType extends AbstractType {
             valueToExpression = code `value.toTerm([${joinCode(this.in_.map((in_) => this.rdfjsTermExpression(in_)), { on: ", " })}])`;
         }
         else if (this.nodeKinds.size < 3) {
-            const eitherTypeParameters = code `<Error, ${this.name}>`;
+            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.name}`.toCodeString([]), focusResource: variables.resource, propertyPath: variables.propertyPath }}));
+  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 {

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

@@ -12,6 +12,10 @@ 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,6 +43,10 @@ export declare abstract class AbstractType {
      * $EqualsResult.
      */
     abstract readonly equalsFunction: Code;
+    /**
+     * TypeScript type expression.
+     */
+    abstract readonly expression: Code;
     /**
      * A function (reference or declaration) that takes a filter of filterType (below) and a value of this type
      * and returns true if the value passes the filter.
@@ -74,10 +82,6 @@ export declare abstract class AbstractType {
      * Is a value of this type mutable?
      */
     abstract readonly mutable: boolean;
-    /**
-     * TypeScript name of the type.
-     */
-    abstract readonly name: Code | string;
     /**
      * Does this type directly or indirectly reference itself?
      */
@@ -133,7 +137,8 @@ export declare abstract class AbstractType {
      * - variablePrefix: string prefix to use for new variables
      */
     abstract readonly valueSparqlWherePatternsFunction: Code;
-    constructor({ comment, configuration, label, logger, reusables, }: {
+    constructor({ alias, comment, configuration, label, logger, reusables, }: {
+        alias: Maybe<string>;
         comment: Maybe<string>;
         configuration: TsGenerator.Configuration;
         label: Maybe<string>;
@@ -160,7 +165,7 @@ export declare abstract class AbstractType {
      * 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 NamedObjectType, either directly (a property with this Type) or indirectly (a property with a Type like OptionType
+     * 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
@@ -169,7 +174,7 @@ export declare abstract class AbstractType {
      * 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 NamedObjectType's fromRdf function:
+     * 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
@@ -204,7 +209,7 @@ export declare abstract class AbstractType {
      * 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 NamedObjectType
+     * "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".
@@ -241,7 +246,7 @@ export declare abstract class AbstractType {
      * An expression that converts a property value of this type to a value or an array of values that can be .add'd to a Resource with
      *   resource.add(predicate, convertedValue, graph)
      *
-     * variables are runtime variables, most derived from the parameters of the NamedObjectType's fromRdf function:
+     * variables are runtime variables, most derived from the parameters of the ObjectType's fromRdf function:
      *   graph: DefaultGraph | NamedNode | undefined to .add to; if undefined, add to the default graph
      *   propertyPath: predicate path (NamedNode) or InversePath on a predicate path
      *   resource: the Resource to .add to
@@ -271,7 +276,7 @@ export declare namespace AbstractType {
     interface ConversionFunction {
         readonly code: Code;
         readonly sourceTypes: {
-            readonly name: Code | string;
+            readonly expression: Code;
             readonly typeof: Typeof;
         }[];
     }

package/dist/generators/ts/AbstractType.js

@@ -14,6 +14,10 @@ export class AbstractType {
     configuration;
     logger;
     reusables;
+    /**
+     * Alias for this type.
+     */
+    alias;
     /**
      * Comment from rdfs:comment.
      */
@@ -22,7 +26,8 @@ export class AbstractType {
      * Label from rdfs:label.
      */
     label;
-    constructor({ comment, configuration, label, logger, reusables, }) {
+    constructor({ alias, comment, configuration, label, logger, reusables, }) {
+        this.alias = alias;
         this.comment = comment;
         this.configuration = configuration;
         this.label = label;

package/dist/generators/ts/BigDecimalType.d.ts

@@ -3,8 +3,8 @@ import { Maybe } from "purify-ts";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class BigDecimalType extends AbstractLiteralType {
-    readonly name: Code;
     readonly conversionFunction: Maybe<AbstractLiteralType.ConversionFunction>;
+    readonly expression: Code;
     readonly filterFunction: Code;
     readonly filterType: Code;
     readonly hashFunction: Code;

package/dist/generators/ts/BigDecimalType.js

@@ -9,8 +9,8 @@ import { Memoize } from "typescript-memoize";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
 import { code, literalOf } from "./ts-poet-wrapper.js";
 export class BigDecimalType extends AbstractLiteralType {
-    name = code `${this.reusables.imports.BigDecimal}`;
     conversionFunction = Maybe.empty();
+    expression = code `${this.reusables.imports.BigDecimal}`;
     filterFunction = code `${this.reusables.snippets.filterBigDecimal}`;
     filterType = code `${this.reusables.snippets.NumericFilter}<${this.reusables.imports.BigDecimal}>`;
     hashFunction = code `${this.reusables.snippets.hashBigDecimal}`;
@@ -21,7 +21,7 @@ export class BigDecimalType extends AbstractLiteralType {
         return new AbstractLiteralType.GraphqlType(code `${this.reusables.imports.GraphQLString}`, this.reusables);
     }
     fromJsonExpression({ variables, }) {
-        return code `${this.reusables.imports.Either}.encase<Error, ${this.name}>(() => new ${this.name}(${variables.value}))`;
+        return code `${this.reusables.imports.Either}.encase<Error, ${this.expression}>(() => new ${this.expression}(${variables.value}))`;
     }
     graphqlResolveExpression({ variables, }) {
         return code `${variables.value}.toFixed()`;

package/dist/generators/ts/BigIntType.js

@@ -17,9 +17,9 @@ export class BigIntType extends AbstractNumericType {
     fromJsonExpression({ variables, }) {
         let expression = code `BigInt(${variables.value})`;
         if (this.primitiveIn.length > 0) {
-            expression = code `${expression} as ${this.name}`;
+            expression = code `${expression} as ${this.expression}`;
         }
-        return code `${this.reusables.imports.Either}.encase<Error, ${this.name}>(() => ${expression})`;
+        return code `${this.reusables.imports.Either}.encase<Error, ${this.expression}>(() => ${expression})`;
     }
     jsonSchema(_parameters) {
         switch (this.primitiveIn.length) {

package/dist/generators/ts/BlankNodeType.d.ts

@@ -4,18 +4,18 @@ import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class BlankNodeType extends AbstractIdentifierType<BlankNode> {
     readonly conversionFunction: Maybe<AbstractIdentifierType.ConversionFunction>;
+    readonly expression: Code;
     readonly filterFunction: Code;
     readonly filterType: Code;
-    readonly parseFunction: Code;
     readonly kind = "BlankNode";
-    readonly name: Code;
     readonly nodeKinds: ReadonlySet<"BlankNode">;
+    readonly parseFunction: Code;
     readonly schemaType: Code;
     readonly valueSparqlWherePatternsFunction: Code;
     constructor(superParameters: Omit<ConstructorParameters<typeof AbstractIdentifierType<BlankNode>>[0], "hasValues" | "in_">);
     fromJsonExpression({ variables, }: Parameters<AbstractIdentifierType<BlankNode>["fromJsonExpression"]>[0]): Code;
-    jsonType(parameters?: Parameters<AbstractIdentifierType<BlankNode>["jsonType"]>[0]): AbstractIdentifierType.JsonType;
     jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractIdentifierType<BlankNode>["jsonSchema"]>[0]): Code;
+    jsonType(parameters?: Parameters<AbstractIdentifierType<BlankNode>["jsonType"]>[0]): AbstractIdentifierType.JsonType;
     toJsonExpression({ includeDiscriminantProperty, variables, }: Parameters<AbstractIdentifierType<BlankNode>["toJsonExpression"]>[0]): Code;
     protected fromRdfResourceValuesExpressionChain({ variables, }: Parameters<AbstractIdentifierType<BlankNode>["fromRdfResourceValuesExpressionChain"]>[0]): {
         valueTo: Code;