@shaclmate/compiler 4.0.38 → 4.0.40

package/dist/generators/ts/{_NamedObjectType/NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration.js → _ObjectType/ObjectType_valueSparqlConstructTriplesFunctionDeclaration.js}

@@ -1,11 +1,11 @@
 import { Maybe } from "purify-ts";
 import { code } from "../ts-poet-wrapper.js";
-export function NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration() {
+export function ObjectType_valueSparqlConstructTriplesFunctionDeclaration() {
     if (!this.configuration.features.has("Object.SPARQL")) {
         return Maybe.empty();
     }
     return Maybe.of(code `\
 export const valueSparqlConstructTriples: ${this.reusables.snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}> = ({ filter, ignoreRdfType, valueVariable, variablePrefix }) =>
-  ${this.name}.focusSparqlConstructTriples({ filter, focusIdentifier: valueVariable, ignoreRdfType, variablePrefix });`);
+  ${this.alias.unsafeCoerce()}.focusSparqlConstructTriples({ filter, focusIdentifier: valueVariable, ignoreRdfType, variablePrefix });`);
 }
-//# sourceMappingURL=NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration.js.map
+//# sourceMappingURL=ObjectType_valueSparqlConstructTriplesFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_valueSparqlWherePatternsFunctionDeclaration.d.ts

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import type { ObjectType } from "../ObjectType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectType_valueSparqlWherePatternsFunctionDeclaration(this: ObjectType): Maybe<Code>;
+//# sourceMappingURL=ObjectType_valueSparqlWherePatternsFunctionDeclaration.d.ts.map

package/dist/generators/ts/{_NamedObjectType/NamedObjectType_valueSparqlWherePatternsFunctionDeclaration.js → _ObjectType/ObjectType_valueSparqlWherePatternsFunctionDeclaration.js}

@@ -1,13 +1,13 @@
 import { Maybe } from "purify-ts";
 import { code } from "../ts-poet-wrapper.js";
-export function NamedObjectType_valueSparqlWherePatternsFunctionDeclaration() {
+export function ObjectType_valueSparqlWherePatternsFunctionDeclaration() {
     if (!this.configuration.features.has("Object.SPARQL")) {
         return Maybe.empty();
     }
     return Maybe.of(code `\
 export const valueSparqlWherePatterns: ${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}> = ({ filter, ignoreRdfType, preferredLanguages, propertyPatterns, valueVariable, variablePrefix }) =>
   (propertyPatterns as readonly ${this.reusables.snippets.SparqlPattern}[]).concat(
-    ${this.name}.focusSparqlWherePatterns({ filter, focusIdentifier: valueVariable, ignoreRdfType, preferredLanguages, variablePrefix })
+    ${this.alias.unsafeCoerce()}.focusSparqlWherePatterns({ filter, focusIdentifier: valueVariable, ignoreRdfType, preferredLanguages, variablePrefix })
   );`);
 }
-//# sourceMappingURL=NamedObjectType_valueSparqlWherePatternsFunctionDeclaration.js.map
+//# sourceMappingURL=ObjectType_valueSparqlWherePatternsFunctionDeclaration.js.map

package/dist/generators/ts/{_NamedObjectType → _ObjectType}/ShaclProperty.d.ts

@@ -8,7 +8,7 @@ export declare class ShaclProperty<TypeT extends Type> extends AbstractProperty<
     private readonly description;
     private readonly display;
     private readonly label;
-    readonly kind = "ShaclProperty";
+    readonly kind = "Shacl";
     readonly mutable: boolean;
     readonly path: PropertyPath;
     readonly recursive: boolean;
@@ -30,11 +30,7 @@ export declare class ShaclProperty<TypeT extends Type> extends AbstractProperty<
     get graphqlField(): AbstractProperty<TypeT>["graphqlField"];
     get jsonSchema(): AbstractProperty<TypeT>["jsonSchema"];
     get jsonSignature(): Maybe<Code>;
-    protected get schemaObject(): {
-        path: Code | undefined;
-        kind: Code;
-        type: Code;
-    };
+    protected get schemaInitializers(): readonly Code[];
     constructorInitializer({ variables, }: Parameters<AbstractProperty<TypeT>["constructorInitializer"]>[0]): Maybe<Code>;
     fromJsonInitializer({ variables, }: Parameters<AbstractProperty<TypeT>["fromJsonInitializer"]>[0]): Maybe<Code>;
     fromRdfResourceValuesInitializer({ variables, }: Parameters<AbstractProperty<TypeT>["fromRdfResourceValuesInitializer"]>[0]): Maybe<Code>;

package/dist/generators/ts/{_NamedObjectType → _ObjectType}/ShaclProperty.js

@@ -14,7 +14,7 @@ export class ShaclProperty extends AbstractProperty {
     description;
     display;
     label;
-    kind = "ShaclProperty";
+    kind = "Shacl";
     mutable;
     path;
     recursive;
@@ -31,7 +31,7 @@ export class ShaclProperty extends AbstractProperty {
     get constructorParameter() {
         const conversionFunction = this.type.conversionFunction.extract();
         if (!conversionFunction) {
-            return Maybe.of(code `readonly ${this.name}: ${this.type.name};`);
+            return Maybe.of(code `readonly ${this.name}: ${this.type.expression};`);
         }
         let hasQuestionToken = false;
         const typeNames = [];
@@ -40,7 +40,7 @@ export class ShaclProperty extends AbstractProperty {
                 hasQuestionToken = true;
             }
             else {
-                typeNames.push(code `${type.name}`);
+                typeNames.push(code `${type.expression}`);
             }
         }
         return Maybe.of(code `readonly ${this.name}${hasQuestionToken ? "?" : ""}: ${joinCode(typeNames, { on: "|" })};`);
@@ -55,7 +55,7 @@ export class ShaclProperty extends AbstractProperty {
             .alt(this.description)
             .alt(this.label)
             .map(tsComment)
-            .orDefault("")}${joinCode(lhs, { on: " " })}: ${this.type.name};`;
+            .orDefault("")}${joinCode(lhs, { on: " " })}: ${this.type.expression};`;
     }
     get filterProperty() {
         return Maybe.of({
@@ -97,24 +97,20 @@ export class ShaclProperty extends AbstractProperty {
         const typeJsonType = this.type.jsonType();
         return Maybe.of(code `${!this.mutable ? "readonly " : ""}${this.name}${typeJsonType.optional ? "?" : ""}: ${typeJsonType.requiredName}`);
     }
-    get schemaObject() {
-        return {
-            ...super.schemaObject,
-            // comment: this.comment.map(JSON.stringify).extract(),
-            // description: this.description.map(JSON.stringify).extract(),
-            path: this.configuration.features.has("Object.fromRdf") ||
-                this.configuration.features.has("Object.toRdf") ||
-                this.configuration.features.has("Object.SPARQL")
-                ? this.propertyPathToCode(this.path)
-                : undefined,
-            // label: this.label.map(JSON.stringify).extract(),
-            // mutable: this.mutable ? true : undefined,
-            // recursive: this.recursive ? true : undefined,
-            // visibility:
-            //   this.visibility !== "public"
-            //     ? `${JSON.stringify(this.visibility)} as const`
-            //     : undefined,
-        };
+    get schemaInitializers() {
+        const initializers = super.schemaInitializers.concat();
+        if (this.configuration.features.has("Object.fromRdf") ||
+            this.configuration.features.has("Object.toRdf")) {
+            initializers.push(code `path: ${this.propertyPathToCode(this.path)}`);
+        }
+        // Use a getter if the type is recursive or the type is an object type, which may have forward references in the file
+        if (this.recursive || this.type.referencesObjectType) {
+            initializers.push(code `get type() { return ${this.type.schema}; }`);
+        }
+        else {
+            initializers.push(code `type: ${this.type.schema}`);
+        }
+        return initializers;
     }
     constructorInitializer({ variables, }) {
         const parameterVariable = code `${variables.parameters}.${this.name}`;
@@ -122,13 +118,13 @@ export class ShaclProperty extends AbstractProperty {
         const validationFunction = this.type.validationFunction.extract();
         let rhs;
         if (conversionFunction && validationFunction) {
-            rhs = code `${conversionFunction}(${parameterVariable}).chain(value => ${validationFunction}(${this.namedObjectType.name}.schema.properties.${this.name}.type(), value))`;
+            rhs = code `${conversionFunction}(${parameterVariable}).chain(value => ${validationFunction}(${this.objectType.alias.unsafeCoerce()}.schema.properties.${this.name}.type, value))`;
         }
         else if (conversionFunction) {
             rhs = code `${conversionFunction}(${parameterVariable})`;
         }
         else if (validationFunction) {
-            rhs = code `${validationFunction}(${this.namedObjectType.name}.schema.properties.${this.name}.type(), ${parameterVariable})`;
+            rhs = code `${validationFunction}(${this.objectType.alias.unsafeCoerce()}.schema.properties.${this.name}.type, ${parameterVariable})`;
         }
         else {
             rhs = code `${this.reusables.imports.Either}.of(${parameterVariable})`;
@@ -152,7 +148,7 @@ export class ShaclProperty extends AbstractProperty {
                 variables: {
                     ...variables,
                     ignoreRdfType: true,
-                    propertyPath: code `${this.namedObjectType.name}.schema.properties.${this.name}.path`,
+                    propertyPath: code `${this.objectType.alias.unsafeCoerce()}.schema.properties.${this.name}.path`,
                     resourceValues: code `resourceValues`,
                 },
             })})`,
@@ -213,7 +209,7 @@ export class ShaclProperty extends AbstractProperty {
             default:
                 return [];
         }
-        const propertyPath = code `${this.namedObjectType.name}.schema.properties.${this.name}.path`;
+        const propertyPath = code `${this.objectType.alias.unsafeCoerce()}.schema.properties.${this.name}.path`;
         return [
             code `${variables.resource}.add(${propertyPath}, ${this.type.toRdfResourceValuesExpression({
                 variables: { ...variables, propertyPath },
@@ -230,12 +226,12 @@ export class ShaclProperty extends AbstractProperty {
         switch (propertyPath.termType) {
             case "AlternativePath":
             case "SequencePath":
-                return code `{ members: [${joinCode(propertyPath.members.map((member) => this.propertyPathToCode(member)), { on: "," })}] as const, termType: ${literalOf(propertyPath.termType)} as const }`;
+                return code `{ members: [${joinCode(propertyPath.members.map((member) => this.propertyPathToCode(member)), { on: "," })}], termType: ${literalOf(propertyPath.termType)} }`;
             case "InversePath":
             case "OneOrMorePath":
             case "ZeroOrMorePath":
             case "ZeroOrOnePath":
-                return code `{ path: ${this.propertyPathToCode(propertyPath.path)}, termType: ${literalOf(propertyPath.termType)} as const }`;
+                return code `{ path: ${this.propertyPathToCode(propertyPath.path)}, termType: ${literalOf(propertyPath.termType)} }`;
             case "NamedNode":
                 return this.rdfjsTermExpression(propertyPath);
         }

package/dist/generators/ts/_ObjectType/identifierTypeDeclarations.d.ts

@@ -0,0 +1,4 @@
+import type { ObjectType } from "../ObjectType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function identifierTypeDeclarations(this: ObjectType): readonly Code[];
+//# sourceMappingURL=identifierTypeDeclarations.d.ts.map

package/dist/generators/ts/{_NamedObjectType → _ObjectType}/identifierTypeDeclarations.js

@@ -1,9 +1,11 @@
+import { codeEquals } from "../codeEquals.js";
 import { code } from "../ts-poet-wrapper.js";
 export function identifierTypeDeclarations() {
     if (!this.configuration.features.has("Object.type")) {
         return [];
     }
-    const ancestorObjectTypeWithSameIdentifierType = this.ancestorObjectTypes.find((ancestorObjectType) => ancestorObjectType.identifierType.name === this.identifierType.name);
+    const ancestorObjectTypeWithSameIdentifierType = this.ancestorObjectTypes.find((ancestorObjectType) => ancestorObjectType.identifierType.kind === this.identifierType.kind &&
+        codeEquals(ancestorObjectType.identifierType.expression, this.identifierType.expression));
     if (ancestorObjectTypeWithSameIdentifierType) {
         // This object type's identifier type has the same identifier type as an ancestor object type,
         // so just reuse the latter.
@@ -14,7 +16,7 @@ export function identifierTypeDeclarations() {
     }
     // Bespoke identifier type and associated functions
     return [
-        code `export type Identifier = ${this.identifierType.name};`,
+        code `export type Identifier = ${this.identifierType.expression};`,
         code `\
 export namespace Identifier {
   export const parse = ${this.identifierType.parseFunction};

package/dist/generators/ts/_snippets/snippets_BooleanSchema.js

@@ -1,7 +1,7 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_BooleanSchema = ({ syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}BooleanSchema`, code `\
-interface ${syntheticNamePrefix}BooleanSchema {
+interface ${syntheticNamePrefix}BooleanSchema<T extends boolean> {
+  readonly in?: readonly T[];
   readonly kind: "Boolean";
-  readonly in?: readonly boolean[];
 }`);
 //# sourceMappingURL=snippets_BooleanSchema.js.map

package/dist/generators/ts/_snippets/snippets_CollectionSchema.js

@@ -1,7 +1,7 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_CollectionSchema = ({ syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}CollectionSchema`, code `\
 interface ${syntheticNamePrefix}CollectionSchema<ItemSchemaT> {
-  readonly item: () => ItemSchemaT;
+  readonly itemType: ItemSchemaT;
   readonly kind: "List" | "Set";
   readonly minCount?: number;
 }`);

package/dist/generators/ts/_snippets/snippets_DefaultValueSchema.js

@@ -2,7 +2,7 @@ import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_DefaultValueSchema = ({ syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}DefaultValueSchema`, code `\
 interface ${syntheticNamePrefix}DefaultValueSchema<DefaultValueT, ItemSchemaT> {
   readonly defaultValue: DefaultValueT;
-  readonly item: () => ItemSchemaT;
+  readonly itemType: ItemSchemaT;
   readonly kind: "DefaultValue";
 }`);
 //# sourceMappingURL=snippets_DefaultValueSchema.js.map

package/dist/generators/ts/_snippets/snippets_IriSchema.js

@@ -1,7 +1,7 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_IriSchema = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}IriSchema`, code `\
-interface ${syntheticNamePrefix}IriSchema {
-  readonly in?: readonly ${imports.NamedNode}[];
+interface ${syntheticNamePrefix}IriSchema<IriT extends string = string> {
+  readonly in?: readonly ${imports.NamedNode}<IriT>[];
   readonly kind: "Iri";
 }`);
 //# sourceMappingURL=snippets_IriSchema.js.map

package/dist/generators/ts/_snippets/snippets_MaybeSchema.js

@@ -1,7 +1,7 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_MaybeSchema = ({ syntheticNamePrefix }) => conditionalOutput(`${syntheticNamePrefix}MaybeSchema`, code `\
 interface ${syntheticNamePrefix}MaybeSchema<ItemSchemaT>{
-  readonly item: () => ItemSchemaT;
-  readonly kind: "Maybe";
+  readonly itemType: ItemSchemaT;
+  readonly kind: "Option";
 }`);
 //# sourceMappingURL=snippets_MaybeSchema.js.map

package/dist/generators/ts/_snippets/snippets_ShaclPropertySchema.js

@@ -3,6 +3,6 @@ export const snippets_ShaclPropertySchema = ({ snippets, syntheticNamePrefix, })
 export interface ${syntheticNamePrefix}ShaclPropertySchema<TypeSchemaT = object> {
   readonly kind: "Shacl";
   readonly path: ${snippets.PropertyPath};
-  readonly type: () => TypeSchemaT;
+  readonly type: TypeSchemaT;
 }`);
 //# sourceMappingURL=snippets_ShaclPropertySchema.js.map

package/dist/generators/ts/_snippets/snippets_StringSchema.js

@@ -1,7 +1,7 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_StringSchema = ({ syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}StringSchema`, code `\
-interface ${syntheticNamePrefix}StringSchema {
-  readonly in?: readonly string[];
+interface ${syntheticNamePrefix}StringSchema<T extends string> {
+  readonly in?: readonly T[];
   readonly kind: "String";
 }`);
 //# sourceMappingURL=snippets_StringSchema.js.map

package/dist/generators/ts/_snippets/snippets_booleanSparqlWherePatterns.js

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_booleanSparqlWherePatterns = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}booleanSparqlWherePatterns`, code `\
-const ${syntheticNamePrefix}booleanSparqlWherePatterns: ${snippets.ValueSparqlWherePatternsFunction}<${snippets.BooleanFilter}, ${snippets.BooleanSchema}> =
+const ${syntheticNamePrefix}booleanSparqlWherePatterns: ${snippets.ValueSparqlWherePatternsFunction}<${snippets.BooleanFilter}, ${snippets.BooleanSchema}<boolean>> =
   ({ filter, valueVariable, ...otherParameters }) => {
     const filterPatterns: ${snippets.SparqlFilterPattern}[] = [];
 

package/dist/generators/ts/_snippets/snippets_convertToIri.js

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_convertToIri = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToIri`, code `\
-function ${syntheticNamePrefix}convertToIri<IriT extends string = string>(value: IriT | ${imports.NamedNode}<IriT>): ${imports.Either}<Error, ${imports.NamedNode}<IriT>> {
+function ${syntheticNamePrefix}convertToIri<IriT extends string>(value: IriT | ${imports.NamedNode}<IriT>): ${imports.Either}<Error, ${imports.NamedNode}<IriT>> {
   switch (typeof value) {
     case "object":
       return ${imports.Either}.of(value);

package/dist/generators/ts/_snippets/snippets_defaultValueSparqlWherePatterns.js

@@ -2,7 +2,7 @@ import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_defaultValueSparqlWherePatterns = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}defaultValueSparqlWherePatterns`, code `\
 function ${syntheticNamePrefix}defaultValueSparqlWherePatterns<ItemFilterT, ItemSchemaT>(itemSparqlWherePatternsFunction: ${snippets.ValueSparqlWherePatternsFunction}<ItemFilterT, ItemSchemaT>): ${snippets.ValueSparqlWherePatternsFunction}<ItemFilterT, ${snippets.DefaultValueSchema}<unknown, ItemSchemaT>> {  
   return ({ schema, ...otherParameters }) => {
-    const [itemSparqlWherePatterns, liftSparqlPatterns] = ${snippets.liftSparqlPatterns}(itemSparqlWherePatternsFunction({ ...otherParameters, schema: schema.item() }));
+    const [itemSparqlWherePatterns, liftSparqlPatterns] = ${snippets.liftSparqlPatterns}(itemSparqlWherePatternsFunction({ ...otherParameters, schema: schema.itemType }));
     return [{ patterns: itemSparqlWherePatterns.concat(), type: "optional" }, ...liftSparqlPatterns];
   }
 }`);

package/dist/generators/ts/_snippets/snippets_ensureRdfResourceType.d.ts

@@ -0,0 +1,3 @@
+import type { SnippetFactory } from "../SnippetFactory.js";
+export declare const snippets_ensureRdfResourceType: SnippetFactory;
+//# sourceMappingURL=snippets_ensureRdfResourceType.d.ts.map

package/dist/generators/ts/_snippets/snippets_ensureRdfResourceType.js

@@ -0,0 +1,16 @@
+import { rdf } from "@tpluscode/rdf-ns-builders";
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_ensureRdfResourceType = ({ imports, rdfjsTermExpression, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}ensureRdfResourceType`, code `\
+function ${syntheticNamePrefix}ensureRdfResourceType(resource: ${imports.Resource}, types: readonly ${imports.NamedNode}[], options: { graph: Exclude<${imports.Quad_Graph}, ${imports.Variable}> | undefined }): ${imports.Either}<Error, undefined> {
+  return resource.value(${rdfjsTermExpression(rdf.type)}, options).chain(actualRdfTypeValue => actualRdfTypeValue.toIri()).chain(actualRdfType => {
+    // Check the expected type and its known subtypes
+    for (const type of types) {
+      if (resource.isInstanceOf(type, options)) {
+        return ${imports.Right}(undefined);
+      }
+    }
+
+    return ${imports.Left}(new Error(\`\${resource.identifier} has unexpected RDF type (actual: \${actualRdfType}, expected one of \${types})\`));
+  });
+}`);
+//# sourceMappingURL=snippets_ensureRdfResourceType.js.map

package/dist/generators/ts/_snippets/snippets_iriSparqlWherePatterns.js

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_iriSparqlWherePatterns = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}iriSparqlWherePatterns`, code `\
-const ${syntheticNamePrefix}iriSparqlWherePatterns: ${snippets.ValueSparqlWherePatternsFunction}<${snippets.IriFilter}, ${snippets.IriSchema}> =
+const ${syntheticNamePrefix}iriSparqlWherePatterns: ${snippets.ValueSparqlWherePatternsFunction}<${snippets.IriFilter}, ${snippets.IriSchema}<string>> =
   ({ filter, valueVariable, ...otherParameters }) => {
     const filterPatterns: ${snippets.SparqlFilterPattern}[] = [];
 

package/dist/generators/ts/_snippets/snippets_listSparqlConstructTriples.js

@@ -10,7 +10,7 @@ function ${syntheticNamePrefix}listSparqlConstructTriples<ItemFilterT, ItemSchem
       // ?list rdf:first ?item0
       const item0Variable = variable("Item0");
       triples.push({ subject: listVariable, predicate: ${snippets.RdfVocabularies}.rdf.first, object: item0Variable });
-      triples = triples.concat(itemSparqlConstructTriplesFunction({ filter, ignoreRdfType: false, schema: schema.item(), valueVariable: item0Variable, variablePrefix: variablePrefix("Item0") }));
+      triples = triples.concat(itemSparqlConstructTriplesFunction({ filter, ignoreRdfType: false, schema: schema.itemType, valueVariable: item0Variable, variablePrefix: variablePrefix("Item0") }));
     }
 
     {
@@ -25,7 +25,7 @@ function ${syntheticNamePrefix}listSparqlConstructTriples<ItemFilterT, ItemSchem
       // ?rest rdf:first ?itemN
       const itemNVariable = variable("ItemN");
       triples.push({ subject: restNVariable, predicate: ${snippets.RdfVocabularies}.rdf.first, object: itemNVariable });
-      triples = triples.concat(itemSparqlConstructTriplesFunction({ filter, ignoreRdfType: false, schema: schema.item(), valueVariable: itemNVariable, variablePrefix: variablePrefix("ItemN") }));
+      triples = triples.concat(itemSparqlConstructTriplesFunction({ filter, ignoreRdfType: false, schema: schema.itemType, valueVariable: itemNVariable, variablePrefix: variablePrefix("ItemN") }));
     }
 
     // ?restN rdf:rest ?restNBasic to get the rdf:rest statement in the CONSTRUCT

package/dist/generators/ts/_snippets/snippets_listSparqlWherePatterns.js

@@ -32,7 +32,7 @@ function ${syntheticNamePrefix}listSparqlWherePatterns<ItemFilterT, ItemSchemaT>
           ignoreRdfType: parameters.ignoreRdfType,
           preferredLanguages: parameters.preferredLanguages,
           propertyPatterns: [],
-          schema: parameters.schema.item(),
+          schema: parameters.schema.itemType,
           valueVariable: item0Variable,
           variablePrefix: variablePrefix("Item0"),
         }),
@@ -88,7 +88,7 @@ function ${syntheticNamePrefix}listSparqlWherePatterns<ItemFilterT, ItemSchemaT>
           ignoreRdfType: parameters.ignoreRdfType,
           preferredLanguages: parameters.preferredLanguages,
           propertyPatterns: [],
-          schema: parameters.schema.item(),
+          schema: parameters.schema.itemType,
           valueVariable: itemNVariable,
           variablePrefix: variablePrefix("ItemN"),
         }),

package/dist/generators/ts/_snippets/snippets_maybeSparqlConstructTriples.js

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_maybeSparqlConstructTriples = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}maybeSparqlConstructTriples`, code `\
 function ${syntheticNamePrefix}maybeSparqlConstructTriples<ItemFilterT, ItemSchemaT>(itemSparqlConstructTriplesFunction: ${snippets.ValueSparqlConstructTriplesFunction}<ItemFilterT, ItemSchemaT>): ${snippets.ValueSparqlConstructTriplesFunction}<${snippets.MaybeFilter}<ItemFilterT>, ${snippets.MaybeSchema}<ItemSchemaT>> {  
-  return ({ filter, schema, ...otherParameters }) => itemSparqlConstructTriplesFunction({ ...otherParameters, filter: filter ?? undefined, schema: schema.item() });
+  return ({ filter, schema, ...otherParameters }) => itemSparqlConstructTriplesFunction({ ...otherParameters, filter: filter ?? undefined, schema: schema.itemType });
 }`);
 //# sourceMappingURL=snippets_maybeSparqlConstructTriples.js.map

package/dist/generators/ts/_snippets/snippets_maybeSparqlWherePatterns.js

@@ -4,18 +4,18 @@ function ${syntheticNamePrefix}maybeSparqlWherePatterns<ItemFilterT, ItemSchemaT
   return ({ filter, schema, ...otherParameters }) => {
     if (filter === undefined) {
       // Treat the item's patterns as optional
-      const [itemSparqlWherePatterns, liftSparqlPatterns] = ${snippets.liftSparqlPatterns}(itemSparqlWherePatternsFunction({ ...otherParameters, filter, schema: schema.item() }));
+      const [itemSparqlWherePatterns, liftSparqlPatterns] = ${snippets.liftSparqlPatterns}(itemSparqlWherePatternsFunction({ ...otherParameters, filter, schema: schema.itemType }));
       return [{ patterns: itemSparqlWherePatterns.concat(), type: "optional" }, ...liftSparqlPatterns];
     }
       
     if (filter === null) {
       // Use FILTER NOT EXISTS around the item's patterns
-      const [itemSparqlWherePatterns, liftSparqlPatterns] = ${snippets.liftSparqlPatterns}(itemSparqlWherePatternsFunction({ ...otherParameters, filter: undefined, schema: schema.item() }));
+      const [itemSparqlWherePatterns, liftSparqlPatterns] = ${snippets.liftSparqlPatterns}(itemSparqlWherePatternsFunction({ ...otherParameters, filter: undefined, schema: schema.itemType }));
       return [{ expression: { args: itemSparqlWherePatterns.concat(), operator: "notexists", type: "operation" }, lift: true, type: "filter" }, ...liftSparqlPatterns]
     }
 
     // Treat the item as required.
-    return itemSparqlWherePatternsFunction({ ...otherParameters, filter, schema: schema.item() });
+    return itemSparqlWherePatternsFunction({ ...otherParameters, filter, schema: schema.itemType });
   }
 }`);
 //# sourceMappingURL=snippets_maybeSparqlWherePatterns.js.map

package/dist/generators/ts/_snippets/snippets_setSparqlConstructTriples.js

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_setSparqlConstructTriples = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}setSparqlConstructTriples`, code `\
 function ${syntheticNamePrefix}setSparqlConstructTriples<ItemFilterT, ItemSchemaT>(itemSparqlConstructTriplesFunction: ${snippets.ValueSparqlConstructTriplesFunction}<ItemFilterT, ItemSchemaT>): ${snippets.ValueSparqlConstructTriplesFunction}<${snippets.CollectionFilter}<ItemFilterT>, ${snippets.CollectionSchema}<ItemSchemaT>> {
-  return ({ schema, ...otherParameters }) => itemSparqlConstructTriplesFunction({ ...otherParameters, schema: schema.item() });
+  return ({ schema, ...otherParameters }) => itemSparqlConstructTriplesFunction({ ...otherParameters, schema: schema.itemType });
 }`);
 //# sourceMappingURL=snippets_setSparqlConstructTriples.js.map

package/dist/generators/ts/_snippets/snippets_setSparqlWherePatterns.js

@@ -2,7 +2,7 @@ import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_setSparqlWherePatterns = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}setSparqlWherePatterns`, code `\
 function ${syntheticNamePrefix}setSparqlWherePatterns<ItemFilterT, ItemSchemaT>(itemSparqlWherePatternsFunction: ${snippets.ValueSparqlWherePatternsFunction}<ItemFilterT, ItemSchemaT>): ${snippets.ValueSparqlWherePatternsFunction}<${snippets.CollectionFilter}<ItemFilterT>, ${snippets.CollectionSchema}<ItemSchemaT>> {
   return ({ filter, schema, ...otherParameters }) => {
-    const itemSparqlWherePatterns = itemSparqlWherePatternsFunction({ ...otherParameters, filter, schema: schema.item() });
+    const itemSparqlWherePatterns = itemSparqlWherePatternsFunction({ ...otherParameters, filter, schema: schema.itemType });
 
     const minCount = filter?.${syntheticNamePrefix}minCount ?? schema.minCount ?? 0;
     if (minCount > 0) {

package/dist/generators/ts/_snippets/snippets_shaclPropertySparqlConstructTriples.js

@@ -82,7 +82,7 @@ function ${syntheticNamePrefix}shaclPropertySparqlConstructTriples<FilterT, Type
     .concat(typeSparqlConstructTriples({
       filter,
       ignoreRdfType,
-      schema: propertySchema.type(),
+      schema: propertySchema.type,
       valueVariable,
       variablePrefix: valueString
     }));

package/dist/generators/ts/_snippets/snippets_shaclPropertySparqlWherePatterns.js

@@ -78,7 +78,7 @@ function ${syntheticNamePrefix}shaclPropertySparqlWherePatterns<FilterT, TypeSch
     ignoreRdfType,
     preferredLanguages,
     propertyPatterns,
-    schema: propertySchema.type(),
+    schema: propertySchema.type,
     valueVariable,
     variablePrefix: valueString
   });

package/dist/generators/ts/_snippets/snippets_stringSparqlWherePatterns.js

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_stringSparqlWherePatterns = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}stringSparqlWherePatterns`, code `\
-const ${syntheticNamePrefix}stringSparqlWherePatterns: ${snippets.ValueSparqlWherePatternsFunction}<${snippets.StringFilter}, ${snippets.StringSchema}> =
+const ${syntheticNamePrefix}stringSparqlWherePatterns: ${snippets.ValueSparqlWherePatternsFunction}<${snippets.StringFilter}, ${snippets.StringSchema}<string>> =
   ({ filter, valueVariable, ...otherParameters }) => {
     const filterPatterns: ${snippets.SparqlFilterPattern}[] = [];
 

package/dist/generators/ts/_snippets/snippets_validateArray.js

@@ -7,7 +7,7 @@ function ${syntheticNamePrefix}validateArray<ItemSchemaT, ItemValueT, Readonly e
       return ${imports.Left}(new Error(\`value array has length (\${valueArray.length}) less than minCount (\${schema.minCount})\`)) as ${imports.Either}<Error, EitherR>;
     }
 
-    return ${imports.Either}.sequence(valueArray.map(value => validateItem(schema.item(), value))) as ${imports.Either}<Error, EitherR>;
+    return ${imports.Either}.sequence(valueArray.map(value => validateItem(schema.itemType, value))) as ${imports.Either}<Error, EitherR>;
   }
 }`);
 //# sourceMappingURL=snippets_validateArray.js.map

package/dist/generators/ts/_snippets/snippets_validateMaybe.js

@@ -2,6 +2,6 @@ import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_validateMaybe = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}validateMaybe`, code `\
 function ${syntheticNamePrefix}validateMaybe<ItemSchemaT, ItemValueT>(validateItem: ${snippets.ValidationFunction}<ItemSchemaT, ItemValueT>) {
   return (schema: ${snippets.MaybeSchema}<ItemSchemaT>, valueMaybe: ${imports.Maybe}<ItemValueT>): ${imports.Either}<Error, ${imports.Maybe}<ItemValueT>> =>
-    valueMaybe.map(value => validateItem(schema.item(), value).map(() => valueMaybe)).orDefault(${imports.Either}.of(valueMaybe));
+    valueMaybe.map(value => validateItem(schema.itemType, value).map(() => valueMaybe)).orDefault(${imports.Either}.of(valueMaybe));
 }`);
 //# sourceMappingURL=snippets_validateMaybe.js.map

package/dist/generators/ts/tsComment.js

@@ -6,6 +6,6 @@ export function tsComment(comment) {
         .trim()
         .split(/\r?\n|\r|\n/g)
         .map((line) => ` * ${line}`)
-        .join("\n")}\n */\n`;
+        .join("\n")}\n **/\n`;
 }
 //# sourceMappingURL=tsComment.js.map