@shaclmate/compiler 4.0.37 → 4.0.39

package/dist/generators/ts/TypeFactory.js

@@ -149,35 +149,35 @@ export class TypeFactory {
     }
     createType(astType, parameters) {
         switch (astType.kind) {
-            case "BlankNodeType":
+            case "BlankNode":
                 return this.createBlankNodeType(astType);
-            case "DefaultValueType":
+            case "DefaultValue":
                 return this.createDefaultValueType(astType);
-            case "IdentifierType":
+            case "Identifier":
                 return this.createIdentifierType(astType);
-            case "IntersectionType":
+            case "Intersection":
                 throw new Error("not implemented");
-            case "IriType":
+            case "Iri":
                 return this.createIriType(astType);
-            case "LazyObjectOptionType":
+            case "LazyObjectOption":
                 return this.createLazyObjectOptionType(astType);
-            case "LazyObjectSetType":
+            case "LazyObjectSet":
                 return this.createLazyObjectSetType(astType);
-            case "LazyObjectType":
+            case "LazyObject":
                 return this.createLazyObjectType(astType);
-            case "ListType":
+            case "List":
                 return this.createListType(astType);
-            case "LiteralType":
+            case "Literal":
                 return this.createLiteralType(astType, parameters);
-            case "ObjectType":
+            case "Object":
                 return this.createNamedObjectType(astType);
-            case "OptionType":
+            case "Option":
                 return this.createOptionType(astType);
-            case "SetType":
+            case "Set":
                 return this.createSetType(astType);
-            case "TermType":
+            case "Term":
                 return this.createTermType(astType);
-            case "UnionType":
+            case "Union":
                 return this.createUnionType(astType);
         }
     }
@@ -240,9 +240,9 @@ export class TypeFactory {
     }
     createIdentifierType(astType) {
         switch (astType.kind) {
-            case "BlankNodeType":
+            case "BlankNode":
                 return this.createBlankNodeType(astType);
-            case "IdentifierType":
+            case "Identifier":
                 return new IdentifierType({
                     comment: astType.comment,
                     configuration: this.configuration,
@@ -250,7 +250,7 @@ export class TypeFactory {
                     logger: this.logger,
                     reusables: this.reusables,
                 });
-            case "IriType":
+            case "Iri":
                 return this.createIriType(astType);
         }
     }

package/dist/generators/ts/ZodGenerator.js

@@ -31,7 +31,7 @@ export namespace ${namedObjectType.name} {
 }`);
         }
         for (const astNamedUnionType of ast_.namedUnionTypes.map((astNamedUnionType) => typeFactory.createUnionType(astNamedUnionType))) {
-            invariant(astNamedUnionType.kind !== "AnonymousUnionType");
+            invariant(astNamedUnionType.kind !== "AnonymousUnion");
             declarations.push(code `\
 export namespace ${astNamedUnionType.name} {
   ${astNamedUnionType.jsonTypeAliasDeclaration}

package/dist/generators/ts/_NamedObjectType/AbstractProperty.d.ts

@@ -1,4 +1,4 @@
-import type { Maybe } from "purify-ts";
+import { Maybe } from "purify-ts";
 import type { Logger } from "ts-log";
 import type { NamedObjectType } from "../NamedObjectType.js";
 import type { Reusables } from "../Reusables.js";
@@ -50,7 +50,7 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "filterF
      */
     abstract readonly jsonSignature: Maybe<Code>;
     /**
-     * Property type discriminant e.g., "ShaclProperty".
+     * Property type discriminant e.g., "Shacl".
      */
     abstract readonly kind: string;
     /**
@@ -80,11 +80,11 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "filterF
     /**
      * TypeScript object describing this type, for runtime use.
      */
-    get schema(): Code;
-    protected get schemaObject(): {
-        kind: Code;
-        type: Code;
-    };
+    get schema(): Maybe<Code>;
+    /**
+     * Helper to compose the result of schema along the type hierarchy.
+     */
+    protected get schemaInitializers(): readonly Code[];
     /**
      * Expression to access the value of this property on an object instance. May evaluate a thunk.
      */

package/dist/generators/ts/_NamedObjectType/AbstractProperty.js

@@ -4,11 +4,10 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { invariant } from "ts-invariant";
+import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
-import { removeUndefined } from "../removeUndefined.js";
-import { code, literalOf } from "../ts-poet-wrapper.js";
+import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
 export class AbstractProperty {
     configuration;
     logger;
@@ -39,15 +38,13 @@ export class AbstractProperty {
      * TypeScript object describing this type, for runtime use.
      */
     get schema() {
-        return code `${removeUndefined(this.schemaObject)}`;
+        return Maybe.of(code `{ ${joinCode(this.schemaInitializers.concat(), { on: ", " })} }`);
     }
-    get schemaObject() {
-        invariant(this.kind.endsWith("Property"));
-        return {
-            kind: code `${literalOf(this.kind.substring(0, this.kind.length - "Property".length))} as const`,
-            // name: literalOf(this.name),
-            type: code `() => (${this.type.schema})`,
-        };
+    /**
+     * Helper to compose the result of schema along the type hierarchy.
+     */
+    get schemaInitializers() {
+        return [code `kind: ${literalOf(this.kind)}`];
     }
     /**
      * Expression to access the value of this property on an object instance. May evaluate a thunk.

package/dist/generators/ts/_NamedObjectType/DiscriminantProperty.d.ts

@@ -5,7 +5,7 @@ export declare class DiscriminantProperty extends AbstractProperty<DiscriminantP
     readonly constructorParameter: Maybe<Code>;
     readonly filterProperty: AbstractProperty<DiscriminantProperty.Type>["filterProperty"];
     readonly graphqlField: AbstractProperty<DiscriminantProperty.Type>["graphqlField"];
-    readonly kind = "DiscriminantProperty";
+    readonly kind = "Discriminant";
     readonly mutable = false;
     readonly recursive = false;
     constructor({ type, ...superParameters }: {
@@ -15,6 +15,7 @@ export declare class DiscriminantProperty extends AbstractProperty<DiscriminantP
     get jsonName(): string;
     get jsonSchema(): AbstractProperty<DiscriminantProperty.Type>["jsonSchema"];
     get jsonSignature(): Maybe<Code>;
+    get schema(): Maybe<Code>;
     private get constValue();
     constructorInitializer(): Maybe<Code>;
     fromJsonInitializer(): Maybe<Code>;

package/dist/generators/ts/_NamedObjectType/DiscriminantProperty.js

@@ -6,14 +6,13 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
-import { removeUndefined } from "../removeUndefined.js";
 import { arrayOf, code, literalOf } from "../ts-poet-wrapper.js";
 import { AbstractProperty } from "./AbstractProperty.js";
 export class DiscriminantProperty extends AbstractProperty {
     constructorParameter = Maybe.empty();
     filterProperty = Maybe.empty();
     graphqlField = Maybe.empty();
-    kind = "DiscriminantProperty";
+    kind = "Discriminant";
     mutable = false;
     recursive = false;
     constructor({ type, ...superParameters }) {
@@ -36,6 +35,12 @@ export class DiscriminantProperty extends AbstractProperty {
     get jsonSignature() {
         return Maybe.of(code `readonly "${this.jsonName}": ${this.type.name}`);
     }
+    get schema() {
+        return Maybe.empty();
+    }
+    // protected override get schemaInitializers(): readonly Code[] {
+    //   return super.schemaInitializers.concat(code`type: ${this.type.schema}`);
+    // }
     get constValue() {
         return code `${literalOf(this.namedObjectType.discriminantValue)} as const`;
     }
@@ -101,11 +106,15 @@ __decorate([
             return `${this.values.map((name) => `"${name}"`).join(" | ")}`;
         }
         get schema() {
-            return code `${removeUndefined({
-                descendantValues: this.descendantValues.length > 0 ? this.descendantValues : undefined,
-                kind: code `${literalOf("TypeDiscriminant")} as const`,
-                ownValues: this.ownValues.length > 0 ? this.ownValues : undefined,
-            })}`;
+            throw new Error("should never be called");
+            // const initializers: Record<string, unknown> = {};
+            // if (this.descendantValues.length > 0) {
+            //   initializers["descendantValues"] = this.descendantValues;
+            // }
+            // if (this.ownValues.length > 0) {
+            //   initializers["ownValues"] = this.ownValues;
+            // }
+            // return code`${initializers}`;
         }
         get values() {
             return this.ownValues.concat(this.descendantValues);

package/dist/generators/ts/_NamedObjectType/IdentifierProperty.d.ts

@@ -6,7 +6,7 @@ import { type Code } from "../ts-poet-wrapper.js";
 import { AbstractProperty } from "./AbstractProperty.js";
 export declare class IdentifierProperty extends AbstractProperty<BlankNodeType | IdentifierType | IriType> {
     private readonly typeAlias;
-    readonly kind = "IdentifierProperty";
+    readonly kind = "Identifier";
     readonly mutable = false;
     readonly recursive = false;
     constructor({ typeAlias, ...superParameters }: {
@@ -22,6 +22,7 @@ export declare class IdentifierProperty extends AbstractProperty<BlankNodeType |
     get graphqlField(): AbstractProperty<IdentifierType>["graphqlField"];
     get jsonSchema(): AbstractProperty<IdentifierType>["jsonSchema"];
     get jsonSignature(): Maybe<Code>;
+    protected get schemaInitializers(): readonly Code[];
     accessExpression({ variables, }: Parameters<AbstractProperty<BlankNodeType | IdentifierType | IriType>["accessExpression"]>[0]): Code;
     constructorInitializer({ variables, }: Parameters<AbstractProperty<IdentifierType>["constructorInitializer"]>[0]): Maybe<Code>;
     fromJsonInitializer({ variables, }: Parameters<AbstractProperty<IdentifierType>["fromJsonInitializer"]>[0]): Maybe<Code>;

package/dist/generators/ts/_NamedObjectType/IdentifierProperty.js

@@ -13,7 +13,7 @@ import { arrayOf, code, joinCode, literalOf, } from "../ts-poet-wrapper.js";
 import { AbstractProperty } from "./AbstractProperty.js";
 export class IdentifierProperty extends AbstractProperty {
     typeAlias;
-    kind = "IdentifierProperty";
+    kind = "Identifier";
     mutable = false;
     recursive = false;
     constructor({ typeAlias, ...superParameters }) {
@@ -56,7 +56,7 @@ export class IdentifierProperty extends AbstractProperty {
     }
     get jsonSchema() {
         let schema;
-        if (this.type.in_.length > 0 && this.type.kind === "IriType") {
+        if (this.type.in_.length > 0 && this.type.kind === "Iri") {
             // Treat sh:in as a union of the IRIs
             // rdfjs.NamedNode<"http://example.com/1" | "http://example.com/2">
             schema = code `${this.reusables.imports.z}.enum(${arrayOf(...this.type.in_.map((iri) => iri.value))})`;
@@ -75,6 +75,9 @@ export class IdentifierProperty extends AbstractProperty {
         }
         return Maybe.of(code `readonly "@id": string`);
     }
+    get schemaInitializers() {
+        return super.schemaInitializers.concat(code `type: ${this.type.schema}`);
+    }
     accessExpression({ variables, }) {
         return code `${variables.object}.${this.name}()`;
     }
@@ -128,7 +131,7 @@ export class IdentifierProperty extends AbstractProperty {
                 ignoreRdfType: true, // Unused
                 preferredLanguages: variables.preferredLanguages,
                 propertyPatterns: code `[]`,
-                schema: code `${this.namedObjectType.name}.schema.properties.${this.name}.type()`,
+                schema: code `${this.namedObjectType.name}.schema.properties.${this.name}.type`,
                 valueVariable: variables.focusIdentifier,
                 variablePrefix: variables.variablePrefix, // Unused
             }})`,

package/dist/generators/ts/_NamedObjectType/NamedObjectType_equalsFunctionDeclaration.js

@@ -10,7 +10,7 @@ export function NamedObjectType_equalsFunctionDeclaration() {
         chain.push(code `${parentObjectType.name}.equals(left, right)`);
     }
     for (const property of this.properties) {
-        if (property.kind === "DiscriminantProperty") {
+        if (property.kind === "Discriminant") {
             continue;
         }
         chain.push(code `(${property.type.equalsFunction})(${property.accessExpression({ variables: { object: code `left` } })}, ${property.accessExpression({ variables: { object: code `right` } })}).mapLeft(propertyValuesUnequal => ({ left, right, propertyName: "${property.name}", propertyValuesUnequal, type: "property" as const }))`);

package/dist/generators/ts/_NamedObjectType/NamedObjectType_fromRdfResourceFunctionDeclaration.js

@@ -1,6 +1,5 @@
-import { rdf } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
-import { code, joinCode } from "../ts-poet-wrapper.js";
+import { arrayOf, code, joinCode } from "../ts-poet-wrapper.js";
 export function NamedObjectType_fromRdfResourceFunctionDeclaration() {
     if (!this.configuration.features.has("Object.fromRdf")) {
         return Maybe.empty();
@@ -31,32 +30,9 @@ export function NamedObjectType_fromRdfResourceFunctionDeclaration() {
         });
         partials.push(`super${parentObjectTypeI}`);
     });
-    this.fromRdfType.ifJust((fromRdfType) => {
-        const fromRdfTypeVariable = this.fromRdfTypeVariable.unsafeCoerce();
-        const predicate = this.rdfjsTermExpression(rdf.type);
-        // Check the expected type and its known subtypes
-        const cases = new Set();
-        cases.add(fromRdfType.value);
-        for (const descendantFromRdfType of this.descendantFromRdfTypes) {
-            cases.add(descendantFromRdfType.value);
-        }
+    this.fromRdfTypeVariable.ifJust((fromRdfTypeVariable) => {
         chains.push({
-            expression: code `!${variables.ignoreRdfType} ? ${variables.resource}.value(${predicate}, ${{ graph: variables.graph }})
-    .chain(actualRdfType => actualRdfType.toIri())
-    .chain((actualRdfType) => {
-      // Check the expected type and its known subtypes
-      switch (actualRdfType.value) {
-        ${[...cases].map((fromRdfType) => `case "${fromRdfType}":`).join("\n")}
-          return ${this.reusables.imports.Right}(true as const);
-      }
-
-      // Check arbitrary rdfs:subClassOf's of the expected type
-      if (${variables.resource}.isInstanceOf(${fromRdfTypeVariable}, ${{ graph: variables.graph }})) {
-        return ${this.reusables.imports.Right}(true as const);
-      }
-
-      return ${this.reusables.imports.Left}(new Error(\`\${${variables.resource}.identifier} has unexpected RDF type (actual: \${actualRdfType.value}, expected: ${fromRdfType.value})\`));
-    }) : ${this.reusables.imports.Right}(true as const)`,
+            expression: code `!${variables.ignoreRdfType} ? ${this.reusables.snippets.ensureRdfResourceType}(${variables.resource}, ${arrayOf(fromRdfTypeVariable, ...this.descendantFromRdfTypeVariables)}, ${{ graph: variables.graph }}) : ${this.reusables.imports.Right}(true as const)`,
             variable: `_rdfTypeCheck`,
         });
     });

package/dist/generators/ts/_NamedObjectType/NamedObjectType_hashFunctionDeclarations.js

@@ -4,7 +4,7 @@ export function NamedObjectType_hashFunctionDeclarations() {
     if (!this.configuration.features.has("Object.hash")) {
         return [];
     }
-    const hashOwnShaclPropertiesStatements = this.properties.flatMap((property) => property.kind === "ShaclProperty"
+    const hashOwnShaclPropertiesStatements = this.properties.flatMap((property) => property.kind === "Shacl"
         ? property.hashStatements({
             variables: {
                 hasher: hasherVariable,
@@ -23,7 +23,7 @@ export function NamedObjectType_hashFunctionDeclarations() {
     hashShaclPropertiesStatements.push(...hashOwnShaclPropertiesStatements);
     hashShaclPropertiesStatements.push(code `return ${hasherVariable};`);
     hashStatements.push(...this.properties
-        .filter((property) => property.kind !== "ShaclProperty")
+        .filter((property) => property.kind !== "Shacl")
         .flatMap((property) => property.hashStatements({
         variables: {
             hasher: hasherVariable,

package/dist/generators/ts/_NamedObjectType/NamedObjectType_interfaceDeclaration.js

@@ -10,7 +10,7 @@ ${this.comment
             .map((parentObjectType) => parentObjectType.name)
             .join(", ")}`
         : ""} {
-  ${joinCode(this.properties.map((property) => property.declaration))}
+  ${joinCode(this.properties.map((property) => property.declaration), { on: "\n\n" })}
 }`;
 }
 //# sourceMappingURL=NamedObjectType_interfaceDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_schemaVariableStatement.js

@@ -7,6 +7,6 @@ export function NamedObjectType_schemaVariableStatement() {
     return Maybe.of(code `\
 export const schema = { properties: { ${joinCode(this.parentObjectTypes
         .map((parentObjectType) => code `...${parentObjectType.name}.schema.properties`)
-        .concat(this.properties.map((property) => code `${property.name}: ${property.schema}`)), { on: ", " })} } } as const;`);
+        .concat(this.properties.flatMap(property => property.schema.toList().map(propertySchema => code `${property.name}: ${propertySchema}`))), { on: ", " })} } } as const;`);
 }
 //# sourceMappingURL=NamedObjectType_schemaVariableStatement.js.map

package/dist/generators/ts/_NamedObjectType/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/ShaclProperty.js

@@ -14,7 +14,7 @@ export class ShaclProperty extends AbstractProperty {
     description;
     display;
     label;
-    kind = "ShaclProperty";
+    kind = "Shacl";
     mutable;
     path;
     recursive;
@@ -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.namedObjectType.name}.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.namedObjectType.name}.schema.properties.${this.name}.type, ${parameterVariable})`;
         }
         else {
             rhs = code `${this.reusables.imports.Either}.of(${parameterVariable})`;
@@ -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/_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