@shaclmate/compiler 4.0.8 → 4.0.10

package/dist/generators/ts/BigIntType.d.ts

@@ -6,7 +6,7 @@ export declare class BigIntType extends AbstractNumericType<bigint> {
     readonly kind = "BigIntType";
     readonly typeofs: NonEmptyList<"bigint">;
     fromJsonExpression({ variables, }: Parameters<AbstractNumericType<bigint>["fromJsonExpression"]>[0]): Code;
-    jsonZodSchema(_parameters: Parameters<AbstractNumericType<bigint>["jsonZodSchema"]>[0]): Code;
+    jsonSchema(_parameters: Parameters<AbstractNumericType<bigint>["jsonSchema"]>[0]): Code;
     jsonType(): AbstractNumericType.JsonType;
     toJsonExpression({ variables, }: Parameters<AbstractNumericType<bigint>["toJsonExpression"]>[0]): Code;
     protected fromRdfResourceValueExpression({ variables, }: Parameters<AbstractNumericType<bigint>["fromRdfResourceValueExpression"]>[0]): Code;

package/dist/generators/ts/BigIntType.js

@@ -20,7 +20,7 @@ export class BigIntType extends AbstractNumericType {
         }
         return expression;
     }
-    jsonZodSchema(_parameters) {
+    jsonSchema(_parameters) {
         switch (this.primitiveIn.length) {
             case 0:
                 return code `${imports.z}.string()`;

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

@@ -10,11 +10,11 @@ export declare class BlankNodeType extends AbstractIdentifierType<BlankNode> {
     readonly name: Code;
     readonly nodeKinds: ReadonlySet<"BlankNode">;
     readonly schemaType: Code;
-    readonly sparqlWherePatternsFunction: Code;
+    readonly valueSparqlWherePatternsFunction: Code;
     constructor(superParameters: Pick<ConstructorParameters<typeof AbstractIdentifierType<BlankNode>>[0], "comment" | "label">);
     fromJsonExpression({ variables, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["fromJsonExpression"]>[0]): Code;
     jsonType(parameters?: Parameters<AbstractTermType["jsonType"]>[0]): AbstractTermType.JsonType;
-    jsonZodSchema({ includeDiscriminantProperty, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["jsonZodSchema"]>[0]): Code;
+    jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["jsonSchema"]>[0]): Code;
     toJsonExpression({ includeDiscriminantProperty, variables, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["toJsonExpression"]>[0]): Code;
     protected fromRdfExpressionChain({ variables, }: Parameters<AbstractTermType["fromRdfExpressionChain"]>[0]): {
         valueTo: Code;

package/dist/generators/ts/BlankNodeType.js

@@ -18,7 +18,7 @@ export class BlankNodeType extends AbstractIdentifierType {
     name = code `${imports.BlankNode}`;
     nodeKinds = nodeKinds;
     schemaType = code `${snippets.BlankNodeSchema}`;
-    sparqlWherePatternsFunction = code `${snippets.blankNodeSparqlWherePatterns}`;
+    valueSparqlWherePatternsFunction = code `${snippets.blankNodeSparqlWherePatterns}`;
     constructor(superParameters) {
         super({
             ...superParameters,
@@ -35,7 +35,7 @@ export class BlankNodeType extends AbstractIdentifierType {
             : "";
         return new AbstractTermType.JsonType(code `{ readonly "@id": string${discriminantProperty} }`);
     }
-    jsonZodSchema({ includeDiscriminantProperty, }) {
+    jsonSchema({ includeDiscriminantProperty, }) {
         const discriminantProperty = includeDiscriminantProperty
             ? code `, termType: ${imports.z}.literal("BlankNode")`
             : "";

package/dist/generators/ts/BooleanType.d.ts

@@ -7,7 +7,7 @@ export declare class BooleanType extends AbstractPrimitiveType<boolean> {
     readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
     readonly kind = "BooleanType";
     readonly schemaType: Code;
-    readonly sparqlWherePatternsFunction: Code;
+    readonly valueSparqlWherePatternsFunction: Code;
     readonly typeofs: NonEmptyList<"boolean">;
     get name(): string;
     protected get schemaObject(): {
@@ -15,8 +15,8 @@ export declare class BooleanType extends AbstractPrimitiveType<boolean> {
         languageIn: import("ts-poet/build/Node.js").Node[] | undefined;
         kind: Code;
     };
-    jsonZodSchema(_parameters: Parameters<AbstractPrimitiveType<number>["jsonZodSchema"]>[0]): Code;
-    toRdfExpression({ variables, }: Parameters<AbstractPrimitiveType<boolean>["toRdfExpression"]>[0]): Code;
+    jsonSchema(_parameters: Parameters<AbstractPrimitiveType<number>["jsonSchema"]>[0]): Code;
+    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<boolean>["toRdfResourceValuesExpression"]>[0]): Code;
     protected fromRdfExpressionChain({ variables, }: Parameters<AbstractPrimitiveType<boolean>["fromRdfExpressionChain"]>[0]): ReturnType<AbstractPrimitiveType<boolean>["fromRdfExpressionChain"]>;
 }
 //# sourceMappingURL=BooleanType.d.ts.map

package/dist/generators/ts/BooleanType.js

@@ -17,7 +17,7 @@ export class BooleanType extends AbstractPrimitiveType {
     graphqlType = new AbstractPrimitiveType.GraphqlType(code `${imports.GraphQLBoolean}`);
     kind = "BooleanType";
     schemaType = code `${snippets.BooleanSchema}`;
-    sparqlWherePatternsFunction = code `${snippets.booleanSparqlWherePatterns}`;
+    valueSparqlWherePatternsFunction = code `${snippets.booleanSparqlWherePatterns}`;
     typeofs = NonEmptyList(["boolean"]);
     get name() {
         if (this.primitiveIn.length > 0) {
@@ -31,13 +31,13 @@ export class BooleanType extends AbstractPrimitiveType {
             in: this.primitiveIn.length > 0 ? this.primitiveIn.concat() : undefined,
         };
     }
-    jsonZodSchema(_parameters) {
+    jsonSchema(_parameters) {
         if (this.primitiveIn.length === 1) {
             return code `${imports.z}.literal(${this.primitiveIn[0]})`;
         }
         return code `${imports.z}.boolean()`;
     }
-    toRdfExpression({ variables, }) {
+    toRdfResourceValuesExpression({ variables, }) {
         return code `[${snippets.literalFactory}.boolean(${variables.value}, ${rdfjsTermExpression(this.datatype)})]`;
     }
     fromRdfExpressionChain({ variables, }) {

package/dist/generators/ts/DateTimeType.d.ts

@@ -3,7 +3,7 @@ import { type Code } from "./ts-poet-wrapper.js";
 export declare class DateTimeType extends AbstractDateType {
     readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
     readonly kind = "DateTimeType";
-    jsonZodSchema(_parameters: Parameters<AbstractDateType["jsonZodSchema"]>[0]): Code;
+    jsonSchema(_parameters: Parameters<AbstractDateType["jsonSchema"]>[0]): Code;
     toJsonExpression({ variables, }: Parameters<AbstractDateType["toJsonExpression"]>[0]): Code;
     protected fromRdfResourceValueExpression({ variables, }: Parameters<AbstractDateType["fromRdfResourceValueExpression"]>[0]): Code;
 }

package/dist/generators/ts/DateTimeType.js

@@ -4,7 +4,7 @@ import { code } from "./ts-poet-wrapper.js";
 export class DateTimeType extends AbstractDateType {
     graphqlType = new AbstractDateType.GraphqlType(code `${imports.GraphQLDateTime}`);
     kind = "DateTimeType";
-    jsonZodSchema(_parameters) {
+    jsonSchema(_parameters) {
         return code `${imports.z}.iso.datetime()`;
     }
     toJsonExpression({ variables, }) {

package/dist/generators/ts/DateType.d.ts

@@ -4,7 +4,7 @@ import { type Code } from "./ts-poet-wrapper.js";
 export declare class DateType extends AbstractDateType {
     readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
     readonly kind = "DateType";
-    jsonZodSchema(_parameters: Parameters<DateTimeType["jsonZodSchema"]>[0]): Code;
+    jsonSchema(_parameters: Parameters<DateTimeType["jsonSchema"]>[0]): Code;
     toJsonExpression({ variables, }: Parameters<AbstractDateType["toJsonExpression"]>[0]): Code;
     protected fromRdfResourceValueExpression({ variables, }: Parameters<AbstractDateType["fromRdfResourceValueExpression"]>[0]): Code;
 }

package/dist/generators/ts/DateType.js

@@ -5,7 +5,7 @@ import { code } from "./ts-poet-wrapper.js";
 export class DateType extends AbstractDateType {
     graphqlType = new DateTimeType.GraphqlType(code `${imports.GraphQLDate}`);
     kind = "DateType";
-    jsonZodSchema(_parameters) {
+    jsonSchema(_parameters) {
         return code `${imports.z}.iso.date()`;
     }
     toJsonExpression({ variables, }) {

package/dist/generators/ts/DefaultValueType.d.ts

@@ -22,8 +22,8 @@ export declare class DefaultValueType<ItemTypeT extends DefaultValueType.ItemTyp
     get mutable(): boolean;
     get name(): Code | string;
     get schemaType(): Code;
-    get sparqlConstructTriplesFunction(): Code;
-    get sparqlWherePatternsFunction(): Code;
+    get valueSparqlConstructTriplesFunction(): Code;
+    get valueSparqlWherePatternsFunction(): Code;
     protected get schemaObject(): {
         defaultValue: Code;
         item: Code;
@@ -32,14 +32,14 @@ export declare class DefaultValueType<ItemTypeT extends DefaultValueType.ItemTyp
     private get defaultValuePrimitiveExpression();
     private get defaultValueTermExpression();
     fromJsonExpression(parameters: Parameters<AbstractType["fromJsonExpression"]>[0]): Code;
-    fromRdfExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["fromRdfExpression"]>[0]): Code;
+    fromRdfResourceValuesExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["fromRdfResourceValuesExpression"]>[0]): Code;
     graphqlResolveExpression(parameters: Parameters<AbstractContainerType<ItemTypeT>["graphqlResolveExpression"]>[0]): Code;
     hashStatements(parameters: Parameters<AbstractContainerType<ItemTypeT>["hashStatements"]>[0]): readonly Code[];
     jsonType(parameters?: Parameters<AbstractContainerType<ItemTypeT>["jsonType"]>[0]): AbstractType.JsonType;
     jsonUiSchemaElement(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonUiSchemaElement"]>[0]): Maybe<Code>;
-    jsonZodSchema(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonZodSchema"]>[0]): Code;
+    jsonSchema(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonSchema"]>[0]): Code;
     toJsonExpression(parameters: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
-    toRdfExpression(parameters: Parameters<AbstractType["toRdfExpression"]>[0]): Code;
+    toRdfResourceValuesExpression(parameters: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
 }
 export declare namespace DefaultValueType {
     type ItemType = Exclude<AbstractContainerType.ItemType, BlankNodeType>;

package/dist/generators/ts/DefaultValueType.js

@@ -56,11 +56,11 @@ export class DefaultValueType extends AbstractContainerType {
     get schemaType() {
         return code `${snippets.DefaultValueSchema}`;
     }
-    get sparqlConstructTriplesFunction() {
-        return this.itemType.sparqlConstructTriplesFunction;
+    get valueSparqlConstructTriplesFunction() {
+        return this.itemType.valueSparqlConstructTriplesFunction;
     }
-    get sparqlWherePatternsFunction() {
-        return code `${snippets.defaultValueSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.sparqlWherePatternsFunction})`;
+    get valueSparqlWherePatternsFunction() {
+        return code `${snippets.defaultValueSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction})`;
     }
     get schemaObject() {
         return {
@@ -102,10 +102,11 @@ export class DefaultValueType extends AbstractContainerType {
             case "TermType":
                 invariant(this.defaultValue.termType === "Literal");
                 return Maybe.of(this.defaultValueTermExpression);
+            case "AnonymousUnionType":
             case "ListType":
-            case "ObjectType":
-            case "ObjectUnionType":
-            case "UnionType":
+            case "NamedObjectType":
+            case "NamedObjectUnionType":
+            case "NamedUnionType":
                 return Maybe.empty();
             default:
                 this.itemType;
@@ -118,8 +119,8 @@ export class DefaultValueType extends AbstractContainerType {
     fromJsonExpression(parameters) {
         return this.itemType.fromJsonExpression(parameters);
     }
-    fromRdfExpression({ variables, }) {
-        return this.itemType.fromRdfExpression({
+    fromRdfResourceValuesExpression({ variables, }) {
+        return this.itemType.fromRdfResourceValuesExpression({
             variables: {
                 ...variables,
                 resourceValues: code `${variables.resourceValues}.map(values => values.length > 0 ? values : new ${imports.Resource}.Value(${{ dataFactory: imports.dataFactory, focusResource: variables.resource, propertyPath: variables.propertyPath, term: this.defaultValueTermExpression }}).toValues())`,
@@ -138,17 +139,17 @@ export class DefaultValueType extends AbstractContainerType {
     jsonUiSchemaElement(parameters) {
         return this.itemType.jsonUiSchemaElement(parameters);
     }
-    jsonZodSchema(parameters) {
-        return this.itemType.jsonZodSchema(parameters);
+    jsonSchema(parameters) {
+        return this.itemType.jsonSchema(parameters);
     }
     toJsonExpression(parameters) {
         return this.itemType.toJsonExpression(parameters);
     }
-    toRdfExpression(parameters) {
+    toRdfResourceValuesExpression(parameters) {
         const { variables } = parameters;
         return this.defaultValuePrimitiveExpression
-            .map((defaultValuePrimitiveExpression) => code `${this.itemType.equalsFunction}(${variables.value}, ${defaultValuePrimitiveExpression}).isLeft() ? ${this.itemType.toRdfExpression(parameters)} : []`)
-            .orDefault(code `${this.itemType.toRdfExpression(parameters)}.filter(value => !value.equals(${this.defaultValueTermExpression}))`);
+            .map((defaultValuePrimitiveExpression) => code `${this.itemType.equalsFunction}(${variables.value}, ${defaultValuePrimitiveExpression}).isLeft() ? ${this.itemType.toRdfResourceValuesExpression(parameters)} : []`)
+            .orDefault(code `${this.itemType.toRdfResourceValuesExpression(parameters)}.filter(value => !value.equals(${this.defaultValueTermExpression}))`);
     }
 }
 __decorate([
@@ -156,10 +157,10 @@ __decorate([
 ], DefaultValueType.prototype, "schemaType", null);
 __decorate([
     Memoize()
-], DefaultValueType.prototype, "sparqlConstructTriplesFunction", null);
+], DefaultValueType.prototype, "valueSparqlConstructTriplesFunction", null);
 __decorate([
     Memoize()
-], DefaultValueType.prototype, "sparqlWherePatternsFunction", null);
+], DefaultValueType.prototype, "valueSparqlWherePatternsFunction", null);
 __decorate([
     Memoize()
 ], DefaultValueType.prototype, "defaultValuePrimitiveExpression", null);

package/dist/generators/ts/IdentifierType.d.ts

@@ -11,11 +11,11 @@ export declare class IdentifierType extends AbstractIdentifierType<BlankNode | N
     readonly name: Code;
     readonly nodeKinds: ReadonlySet<IdentifierNodeKind>;
     readonly schemaType: Code;
-    readonly sparqlWherePatternsFunction: Code;
+    readonly valueSparqlWherePatternsFunction: Code;
     constructor(parameters: Pick<ConstructorParameters<typeof AbstractIdentifierType<BlankNode | NamedNode>>[0], "comment" | "label">);
     fromJsonExpression({ variables, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["fromJsonExpression"]>[0]): Code;
     jsonType(parameters?: Parameters<AbstractTermType["jsonType"]>[0]): AbstractTermType.JsonType;
-    jsonZodSchema({ includeDiscriminantProperty, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["jsonZodSchema"]>[0]): Code;
+    jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["jsonSchema"]>[0]): Code;
     toJsonExpression({ includeDiscriminantProperty, variables, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["toJsonExpression"]>[0]): Code;
     protected fromRdfExpressionChain({ variables, }: Parameters<AbstractTermType["fromRdfExpressionChain"]>[0]): ReturnType<AbstractTermType["fromRdfExpressionChain"]>;
 }

package/dist/generators/ts/IdentifierType.js

@@ -19,7 +19,7 @@ export class IdentifierType extends AbstractIdentifierType {
     name = code `(${imports.BlankNode} | ${imports.NamedNode})`;
     nodeKinds = nodeKinds;
     schemaType = code `${snippets.IdentifierSchema}`;
-    sparqlWherePatternsFunction = code `${snippets.identifierSparqlWherePatterns}`;
+    valueSparqlWherePatternsFunction = code `${snippets.identifierSparqlWherePatterns}`;
     constructor(parameters) {
         super({
             ...parameters,
@@ -36,7 +36,7 @@ export class IdentifierType extends AbstractIdentifierType {
             : "";
         return new AbstractTermType.JsonType(code `{ readonly "@id": string${discriminantProperty} }`);
     }
-    jsonZodSchema({ includeDiscriminantProperty, }) {
+    jsonSchema({ includeDiscriminantProperty, }) {
         const discriminantProperty = includeDiscriminantProperty
             ? code `, termType: ${imports.z}.enum(${arrayOf(...this.nodeKinds)})`
             : "";

package/dist/generators/ts/IriType.d.ts

@@ -8,7 +8,7 @@ export declare class IriType extends AbstractIdentifierType<NamedNode> {
     readonly kind = "IriType";
     readonly nodeKinds: ReadonlySet<"IRI">;
     readonly schemaType: Code;
-    readonly sparqlWherePatternsFunction: Code;
+    readonly valueSparqlWherePatternsFunction: Code;
     get fromStringFunction(): Code;
     get name(): Code;
     protected get schemaObject(): {
@@ -17,7 +17,7 @@ export declare class IriType extends AbstractIdentifierType<NamedNode> {
     };
     fromJsonExpression({ variables, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["fromJsonExpression"]>[0]): Code;
     jsonType(parameters?: Parameters<AbstractTermType["jsonType"]>[0]): AbstractTermType.JsonType;
-    jsonZodSchema({ includeDiscriminantProperty, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["jsonZodSchema"]>[0]): Code;
+    jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["jsonSchema"]>[0]): Code;
     toJsonExpression({ includeDiscriminantProperty, variables, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["toJsonExpression"]>[0]): Code;
     protected fromRdfExpressionChain({ variables, }: Parameters<AbstractTermType["fromRdfExpressionChain"]>[0]): ReturnType<AbstractTermType["fromRdfExpressionChain"]>;
 }

package/dist/generators/ts/IriType.js

@@ -17,7 +17,7 @@ export class IriType extends AbstractIdentifierType {
     kind = "IriType";
     nodeKinds = nodeKinds;
     schemaType = code `${snippets.IriSchema}`;
-    sparqlWherePatternsFunction = code `${snippets.iriSparqlWherePatterns}`;
+    valueSparqlWherePatternsFunction = code `${snippets.iriSparqlWherePatterns}`;
     get fromStringFunction() {
         const expressions = [
             code `${imports.Either}.encase(() => ${imports.Resource}.Identifier.fromString({ ${imports.dataFactory}, identifier }))`,
@@ -63,7 +63,7 @@ export function fromString(identifier: string): ${imports.Either}<Error, ${this.
         }
         return new AbstractTermType.JsonType(code `{ readonly "@id": string${discriminantProperty} }`);
     }
-    jsonZodSchema({ includeDiscriminantProperty, }) {
+    jsonSchema({ includeDiscriminantProperty, }) {
         let idSchema;
         if (this.in_.length > 0) {
             // Treat sh:in as a union of the IRIs

package/dist/generators/ts/LazyObjectOptionType.d.ts

@@ -24,7 +24,7 @@ export declare class LazyObjectOptionType extends Super {
     constructor({ partialType, resolveType, ...superParameters }: Omit<ConstructorParameters<typeof AbstractLazyObjectType<OptionType<AbstractLazyObjectType.ObjectTypeConstraint>, OptionType<AbstractLazyObjectType.ObjectTypeConstraint>>>[0], "runtimeClass">);
     get conversions(): readonly AbstractLazyObjectType.Conversion[];
     fromJsonExpression(parameters: Parameters<Super["fromJsonExpression"]>[0]): Code;
-    fromRdfExpression(parameters: Parameters<Super["fromRdfExpression"]>[0]): Code;
+    fromRdfResourceValuesExpression(parameters: Parameters<Super["fromRdfResourceValuesExpression"]>[0]): Code;
     graphqlResolveExpression({ variables, }: Parameters<Super["graphqlResolveExpression"]>[0]): Code;
 }
 export {};

package/dist/generators/ts/LazyObjectOptionType.js

@@ -28,7 +28,7 @@ export class LazyObjectOptionType extends Super {
     }
     get conversions() {
         const conversions = super.conversions.concat();
-        if (this.partialType.itemType.kind === "ObjectType") {
+        if (this.partialType.itemType.kind === "NamedObjectType") {
             conversions.push({
                 conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${value}.map(object => ${this.partialType.itemType.newExpression({ parameters: code `object` })}), resolver: async () => ${imports.Right}((${value} as ${imports.Maybe}<${this.resolveType.itemType.name}>).unsafeCoerce()) })`,
                 sourceTypeCheckExpression: (value) => code `${imports.Maybe}.isMaybe(${value})`,
@@ -36,18 +36,18 @@ export class LazyObjectOptionType extends Super {
                 sourceTypeof: "object",
             }, {
                 conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${imports.Maybe}.of(${this.partialType.itemType.newExpression({ parameters: value })}), resolver: async () => ${imports.Right}(${value} as ${this.resolveType.itemType.name}) })`,
-                // Don't check instanceof value since the ObjectUnionType may be an interface
+                // Don't check instanceof value since the NamedObjectUnionType may be an interface
                 // Rely on the fact that this will be the last type check on an object
                 sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
                 sourceTypeName: this.resolveType.itemType.name,
                 sourceTypeof: "object",
             });
         }
-        else if (this.resolveType.itemType.kind === "ObjectUnionType" &&
-            this.partialType.itemType.kind === "ObjectUnionType" &&
-            this.resolveType.itemType.memberTypes.length ===
-                this.partialType.itemType.memberTypes.length) {
-            const maybeMap = code `.map(object => { ${this.resolvedObjectUnionTypeToPartialObjectUnionTypeConversion({ resolvedObjectUnionType: this.resolveType.itemType, partialObjectUnionType: this.partialType.itemType, variables: { resolvedObjectUnion: code `object` } })} })`;
+        else if (this.resolveType.itemType.kind === "NamedObjectUnionType" &&
+            this.partialType.itemType.kind === "NamedObjectUnionType" &&
+            this.resolveType.itemType.members.length ===
+                this.partialType.itemType.members.length) {
+            const maybeMap = code `.map(object => { ${this.resolvedNamedObjectUnionTypeToPartialNamedObjectUnionTypeConversion({ resolvedNamedObjectUnionType: this.resolveType.itemType, partialNamedObjectUnionType: this.partialType.itemType, variables: { resolvedObjectUnion: code `object` } })} })`;
             conversions.push({
                 conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${value}${maybeMap}, resolver: async () => ${imports.Right}((${value} as ${imports.Maybe}<${this.resolveType.itemType.name}>).unsafeCoerce()) })`,
                 sourceTypeCheckExpression: (value) => code `${imports.Maybe}.isMaybe(${value})`,
@@ -55,7 +55,7 @@ export class LazyObjectOptionType extends Super {
                 sourceTypeof: "object",
             }, {
                 conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${imports.Maybe}.of(${value})${maybeMap}, resolver: async () => ${imports.Right}(${value} as ${this.resolveType.itemType.name}) })`,
-                // Don't check instanceof value since the ObjectUnionType may be an interface
+                // Don't check instanceof value since the NamedObjectUnionType may be an interface
                 // Rely on the fact that this will be the last type check on an object
                 sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
                 sourceTypeName: this.resolveType.itemType.name,
@@ -73,9 +73,9 @@ export class LazyObjectOptionType extends Super {
     fromJsonExpression(parameters) {
         return code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${this.partialType.fromJsonExpression(parameters)}, resolver: (identifier) => Promise.resolve(${imports.Left}(new Error(\`unable to resolve identifier \${${imports.Resource}.Identifier.toString(identifier)} deserialized from JSON\`))) })`;
     }
-    fromRdfExpression(parameters) {
+    fromRdfResourceValuesExpression(parameters) {
         const { variables } = parameters;
-        return code `${this.partialType.fromRdfExpression(parameters)}.map(values => values.map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: (identifier, options) => ${variables.objectSet}.${this.resolveType.itemType.objectSetMethodNames.object}(identifier, options) })))`;
+        return code `${this.partialType.fromRdfResourceValuesExpression(parameters)}.map(values => values.map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: (identifier, options) => ${variables.objectSet}.${this.resolveType.itemType.objectSetMethodNames.object}(identifier, options) })))`;
     }
     graphqlResolveExpression({ variables, }) {
         return code `${variables.value}.resolve().then(either => either.unsafeCoerce().extractNullable())`;

package/dist/generators/ts/LazyObjectSetType.d.ts

@@ -7,7 +7,7 @@ export declare class LazyObjectSetType extends AbstractLazyObjectType<SetType<Ab
     constructor({ partialType, resolveType, ...superParameters }: Omit<ConstructorParameters<typeof AbstractLazyObjectType<SetType<AbstractLazyObjectType.ObjectTypeConstraint>, SetType<AbstractLazyObjectType.ObjectTypeConstraint>>>[0], "runtimeClass">);
     get conversions(): readonly AbstractLazyObjectType.Conversion[];
     fromJsonExpression(parameters: Parameters<Super["fromJsonExpression"]>[0]): Code;
-    fromRdfExpression(parameters: Parameters<Super["fromRdfExpression"]>[0]): Code;
+    fromRdfResourceValuesExpression(parameters: Parameters<Super["fromRdfResourceValuesExpression"]>[0]): Code;
     graphqlResolveExpression({ variables, }: Parameters<Super["graphqlResolveExpression"]>[0]): Code;
 }
 type Super = AbstractLazyObjectType<SetType<AbstractLazyObjectType.ObjectTypeConstraint>, SetType<AbstractLazyObjectType.ObjectTypeConstraint>>;

package/dist/generators/ts/LazyObjectSetType.js

@@ -34,7 +34,7 @@ export class LazyObjectSetType extends AbstractLazyObjectType {
     }
     get conversions() {
         const conversions = super.conversions.concat();
-        if (this.partialType.itemType.kind === "ObjectType") {
+        if (this.partialType.itemType.kind === "NamedObjectType") {
             conversions.push({
                 conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${value}.map(object => ${this.partialType.itemType.newExpression({ parameters: code `object` })}), resolver: async () => ${imports.Right}(${value} as readonly ${this.resolveType.itemType.name}[]) })`,
                 sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
@@ -42,12 +42,12 @@ export class LazyObjectSetType extends AbstractLazyObjectType {
                 sourceTypeof: "object",
             });
         }
-        else if (this.resolveType.itemType.kind === "ObjectUnionType" &&
-            this.partialType.itemType.kind === "ObjectUnionType" &&
-            this.resolveType.itemType.memberTypes.length ===
-                this.partialType.itemType.memberTypes.length) {
+        else if (this.resolveType.itemType.kind === "NamedObjectUnionType" &&
+            this.partialType.itemType.kind === "NamedObjectUnionType" &&
+            this.resolveType.itemType.members.length ===
+                this.partialType.itemType.members.length) {
             conversions.push({
-                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${value}.map(object => { ${this.resolvedObjectUnionTypeToPartialObjectUnionTypeConversion({ resolvedObjectUnionType: this.resolveType.itemType, partialObjectUnionType: this.partialType.itemType, variables: { resolvedObjectUnion: code `object` } })} }), resolver: async () => ${imports.Right}(${value} as readonly ${this.resolveType.itemType.name}[]) })`,
+                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${value}.map(object => { ${this.resolvedNamedObjectUnionTypeToPartialNamedObjectUnionTypeConversion({ resolvedNamedObjectUnionType: this.resolveType.itemType, partialNamedObjectUnionType: this.partialType.itemType, variables: { resolvedObjectUnion: code `object` } })} }), resolver: async () => ${imports.Right}(${value} as readonly ${this.resolveType.itemType.name}[]) })`,
                 sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
                 sourceTypeName: code `readonly ${this.resolveType.itemType.name}[]`,
                 sourceTypeof: "object",
@@ -64,9 +64,9 @@ export class LazyObjectSetType extends AbstractLazyObjectType {
     fromJsonExpression(parameters) {
         return code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${this.partialType.fromJsonExpression(parameters)}, resolver: () => Promise.resolve(${imports.Left}(new Error("unable to resolve identifiers deserialized from JSON"))) })`;
     }
-    fromRdfExpression(parameters) {
+    fromRdfResourceValuesExpression(parameters) {
         const { variables } = parameters;
-        return code `${this.partialType.fromRdfExpression(parameters)}.map(values => values.map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: (identifiers, options) => ${variables.objectSet}.${this.resolveType.itemType.objectSetMethodNames.objects}({ identifiers, ...options }) })))`;
+        return code `${this.partialType.fromRdfResourceValuesExpression(parameters)}.map(values => values.map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: (identifiers, options) => ${variables.objectSet}.${this.resolveType.itemType.objectSetMethodNames.objects}({ identifiers, ...options }) })))`;
     }
     graphqlResolveExpression({ variables, }) {
         return code `(${variables.value}.resolve({ limit: ${variables.args}.limit, offset: ${variables.args}.offset })).then(either => either.unsafeCoerce())`;

package/dist/generators/ts/LazyObjectType.d.ts

@@ -6,7 +6,7 @@ export declare class LazyObjectType extends AbstractLazyObjectType<AbstractLazyO
     constructor({ partialType, resolveType, ...superParameters }: Omit<ConstructorParameters<typeof AbstractLazyObjectType<AbstractLazyObjectType.ObjectTypeConstraint, AbstractLazyObjectType.ObjectTypeConstraint>>[0], "runtimeClass">);
     get conversions(): readonly AbstractLazyObjectType.Conversion[];
     fromJsonExpression(parameters: Parameters<Super["fromJsonExpression"]>[0]): Code;
-    fromRdfExpression(parameters: Parameters<Super["fromRdfExpression"]>[0]): Code;
+    fromRdfResourceValuesExpression(parameters: Parameters<Super["fromRdfResourceValuesExpression"]>[0]): Code;
     graphqlResolveExpression({ variables, }: Parameters<Super["graphqlResolveExpression"]>[0]): Code;
 }
 type Super = AbstractLazyObjectType<AbstractLazyObjectType.ObjectTypeConstraint, AbstractLazyObjectType.ObjectTypeConstraint>;

package/dist/generators/ts/LazyObjectType.js

@@ -20,23 +20,22 @@ export class LazyObjectType extends AbstractLazyObjectType {
     }
     get conversions() {
         const conversions = super.conversions.concat();
-        if (this.partialType.kind === "ObjectType") {
+        if (this.partialType.kind === "NamedObjectType") {
             conversions.push({
                 conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${this.partialType.newExpression({ parameters: value })}, resolver: async () => ${imports.Right}(${value} as ${this.resolveType.name}) })`,
-                // Don't check instanceof value since the ObjectType may be an interface
+                // Don't check instanceof value since the NamedObjectType may be an interface
                 // Rely on the fact that this will be the last type check on an object
                 sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
                 sourceTypeName: this.resolveType.name,
                 sourceTypeof: "object",
             });
         }
-        else if (this.resolveType.kind === "ObjectUnionType" &&
-            this.partialType.kind === "ObjectUnionType" &&
-            this.resolveType.memberTypes.length ===
-                this.partialType.memberTypes.length) {
+        else if (this.resolveType.kind === "NamedObjectUnionType" &&
+            this.partialType.kind === "NamedObjectUnionType" &&
+            this.resolveType.members.length === this.partialType.members.length) {
             conversions.push({
-                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ((object: ${this.resolveType.name}) => { ${this.resolvedObjectUnionTypeToPartialObjectUnionTypeConversion({ resolvedObjectUnionType: this.resolveType, partialObjectUnionType: this.partialType, variables: { resolvedObjectUnion: code `object` } })} })(${value}), resolver: async () => ${imports.Right}(${value} as ${this.resolveType.name}) })`,
-                // Don't check instanceof value since the ObjectUnionType may be an interface
+                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ((object: ${this.resolveType.name}) => { ${this.resolvedNamedObjectUnionTypeToPartialNamedObjectUnionTypeConversion({ resolvedNamedObjectUnionType: this.resolveType, partialNamedObjectUnionType: this.partialType, variables: { resolvedObjectUnion: code `object` } })} })(${value}), resolver: async () => ${imports.Right}(${value} as ${this.resolveType.name}) })`,
+                // Don't check instanceof value since the NamedObjectUnionType may be an interface
                 // Rely on the fact that this will be the last type check on an object
                 sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
                 sourceTypeName: this.resolveType.name,
@@ -48,9 +47,9 @@ export class LazyObjectType extends AbstractLazyObjectType {
     fromJsonExpression(parameters) {
         return code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${this.partialType.fromJsonExpression(parameters)}, resolver: (identifier) => Promise.resolve(${imports.Left}(new Error(\`unable to resolve identifier \${${imports.Resource}.Identifier.toString(identifier)} deserialized from JSON\`))) })`;
     }
-    fromRdfExpression(parameters) {
+    fromRdfResourceValuesExpression(parameters) {
         const { variables } = parameters;
-        return code `${this.partialType.fromRdfExpression(parameters)}.map(values => values.map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: (identifier, options) => ${variables.objectSet}.${this.resolveType.objectSetMethodNames.object}(identifier, options) })))`;
+        return code `${this.partialType.fromRdfResourceValuesExpression(parameters)}.map(values => values.map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: (identifier, options) => ${variables.objectSet}.${this.resolveType.objectSetMethodNames.object}(identifier, options) })))`;
     }
     graphqlResolveExpression({ variables, }) {
         return code `${variables.value}.resolve().then(either => either.unsafeCoerce())`;

package/dist/generators/ts/ListType.d.ts

@@ -2,6 +2,7 @@ import type { NamedNode } from "@rdfjs/types";
 import type { Maybe } from "purify-ts";
 import type { IdentifierMintingStrategy } from "../../enums/IdentifierMintingStrategy.js";
 import { AbstractCollectionType } from "./AbstractCollectionType.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 +14,13 @@ import type { IdentifierType } from "./IdentifierType.js";
 import type { IntType } from "./IntType.js";
 import type { IriType } from "./IriType.js";
 import type { LiteralType } from "./LiteralType.js";
-import type { ObjectType } from "./ObjectType.js";
-import type { ObjectUnionType } from "./ObjectUnionType.js";
+import type { NamedObjectType } from "./NamedObjectType.js";
+import type { NamedObjectUnionType } from "./NamedObjectUnionType.js";
+import type { NamedUnionType } from "./NamedUnionType.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";
 export declare class ListType<ItemTypeT extends ListType.ItemType> extends AbstractCollectionType<ItemTypeT> {
     private readonly identifierMintingStrategy;
     private readonly identifierNodeKind;
@@ -30,14 +31,14 @@ export declare class ListType<ItemTypeT extends ListType.ItemType> extends Abstr
         identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
         toRdfTypes: readonly NamedNode[];
     } & ConstructorParameters<typeof AbstractCollectionType<ItemTypeT>>[0]);
-    get sparqlConstructTriplesFunction(): Code;
-    get sparqlWherePatternsFunction(): Code;
-    fromRdfExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["fromRdfExpression"]>[0]): Code;
+    get valueSparqlConstructTriplesFunction(): Code;
+    get valueSparqlWherePatternsFunction(): Code;
+    fromRdfResourceValuesExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["fromRdfResourceValuesExpression"]>[0]): Code;
     jsonType(): AbstractCollectionType.JsonType;
-    toRdfExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["toRdfExpression"]>[0]): Code;
+    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["toRdfResourceValuesExpression"]>[0]): Code;
 }
 export declare namespace ListType {
-    type ItemType = BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | FloatType | IdentifierType | IntType | IriType | LiteralType | ObjectType | ObjectUnionType | StringType | TermType | UnionType;
+    type ItemType = AnonymousUnionType | BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | FloatType | IdentifierType | IntType | IriType | LiteralType | NamedObjectUnionType | NamedUnionType | NamedObjectType | StringType | TermType;
     function isItemType(type: Type): type is ItemType;
 }
 //# sourceMappingURL=ListType.d.ts.map