@shaclmate/compiler 4.0.41 → 4.0.43

package/dist/generators/ts/_ObjectType/ShaclProperty.js

@@ -31,7 +31,10 @@ export class ShaclProperty extends AbstractProperty {
     get constructorParameter() {
         const conversionFunction = this.type.conversionFunction.extract();
         if (!conversionFunction) {
-            return Maybe.of(code `readonly ${this.name}: ${this.type.expression};`);
+            return Maybe.of({
+                hasQuestionToken: false,
+                signature: code `readonly ${this.name}: ${this.type.expression};`,
+            });
         }
         let hasQuestionToken = false;
         const typeExpressions = [];
@@ -43,19 +46,21 @@ export class ShaclProperty extends AbstractProperty {
                 typeExpressions.push(code `${type.expression}`);
             }
         }
-        return Maybe.of(code `readonly ${this.name}${hasQuestionToken ? "?" : ""}: ${joinCode(typeExpressions, { on: "|" })};`);
+        return Maybe.of({
+            hasQuestionToken,
+            signature: code `readonly ${this.name}${hasQuestionToken ? "?" : ""}: ${joinCode(typeExpressions, { on: "|" })};`,
+        });
     }
     get declaration() {
-        const lhs = [];
-        if (!this.mutable) {
-            lhs.push(code `readonly`);
-        }
-        lhs.push(code `${this.name}`);
-        return code `${this.comment
+        let declaration = code `${!this.mutable ? "readonly " : ""}${this.name}: ${this.type.expression};`;
+        this.comment
             .alt(this.description)
             .alt(this.label)
             .map(tsComment)
-            .orDefault("")}${joinCode(lhs, { on: " " })}: ${this.type.expression};`;
+            .ifJust((comment) => {
+            declaration = code `${comment}${declaration}`;
+        });
+        return declaration;
     }
     get filterProperty() {
         return Maybe.of({
@@ -74,6 +79,9 @@ export class ShaclProperty extends AbstractProperty {
             type: this.type.graphqlType.expression,
         });
     }
+    get hashFunctionParameter() {
+        return this.declaration;
+    }
     get jsonSchema() {
         let schema = this.type.jsonSchema({
             context: "property",
@@ -97,20 +105,39 @@ export class ShaclProperty extends AbstractProperty {
         const typeJsonType = this.type.jsonType();
         return Maybe.of(code `${!this.mutable ? "readonly " : ""}${this.name}${typeJsonType.optional ? "?" : ""}: ${typeJsonType.requiredExpression}`);
     }
-    get schemaInitializers() {
-        const initializers = super.schemaInitializers.concat();
+    get schema() {
+        const initializers = [code `kind: ${literalOf(this.kind)}`];
         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) {
+        if (this.recursive || this.type.referencesNamedType) {
             initializers.push(code `get type() { return ${this.type.schema}; }`);
         }
         else {
             initializers.push(code `type: ${this.type.schema}`);
         }
-        return initializers;
+        return Maybe.of(code `{ ${joinCode(initializers, { on: ", " })} }`);
+    }
+    get schemaType() {
+        const initializers = [code `readonly kind: ${literalOf(this.kind)}`];
+        if (this.configuration.features.has("Object.fromRdf") ||
+            this.configuration.features.has("Object.toRdf")) {
+            initializers.push(code `readonly path: ${this.reusables.snippets.PropertyPath}`);
+        }
+        initializers.push(code `readonly type: ${this.type.schemaType}`);
+        return Maybe.of(code `{ ${joinCode(initializers, { on: ", " })} }`);
+    }
+    get schemaVariable() {
+        return this.objectType.name
+            .map((name) => code `${name}.schema.properties.${this.name}`)
+            .orDefaultLazy(() => this.schema.unsafeCoerce());
+    }
+    get typeSchemaVariable() {
+        return this.objectType.name
+            .map((name) => code `${name}.schema.properties.${this.name}.type`)
+            .orDefaultLazy(() => this.type.schema);
     }
     constructorInitializer({ variables, }) {
         const parameterVariable = code `${variables.parameters}.${this.name}`;
@@ -118,13 +145,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.objectType.alias.unsafeCoerce()}.schema.properties.${this.name}.type, value))`;
+            rhs = code `${conversionFunction}(${parameterVariable}).chain(value => ${validationFunction}(${this.typeSchemaVariable}, value))`;
         }
         else if (conversionFunction) {
             rhs = code `${conversionFunction}(${parameterVariable})`;
         }
         else if (validationFunction) {
-            rhs = code `${validationFunction}(${this.objectType.alias.unsafeCoerce()}.schema.properties.${this.name}.type, ${parameterVariable})`;
+            rhs = code `${validationFunction}(${this.typeSchemaVariable}, ${parameterVariable})`;
         }
         else {
             rhs = code `${this.reusables.imports.Either}.of(${parameterVariable})`;
@@ -137,22 +164,22 @@ export class ShaclProperty extends AbstractProperty {
         })}`);
     }
     fromRdfResourceValuesInitializer({ variables, }) {
-        // Assume the property has the correct range and ignore the object's RDF type.
-        // This also accommodates the case where the object of a property is a dangling identifier that's not the
-        // subject of any statements.
-        return Maybe.of(code `${this.name}: ${this.reusables.snippets.shaclPropertyFromRdf}(${{
+        const parameters = {
+            context: variables.context,
             graph: variables.graph,
-            resource: variables.resource,
-            propertySchema: code `schema.properties.${this.name}`,
-            typeFromRdf: code `((resourceValues) => ${this.type.fromRdfResourceValuesExpression({
-                variables: {
-                    ...variables,
-                    ignoreRdfType: true,
-                    propertyPath: code `${this.objectType.alias.unsafeCoerce()}.schema.properties.${this.name}.path`,
-                    resourceValues: code `resourceValues`,
-                },
-            })})`,
-        }})`);
+            focusResource: variables.focusResource,
+            // Assume the property has the correct range and ignore the object's RDF type.
+            // This also accommodates the case where the object of a property is a dangling identifier that's not the
+            // subject of any statements.
+            ignoreRdfType: true,
+            preferredLanguages: variables.preferredLanguages,
+            propertySchema: this.schemaVariable,
+            typeFromRdfResourceValues: this.type.fromRdfResourceValuesFunction,
+        };
+        if (this.configuration.features.has("ObjectSet")) {
+            parameters["objectSet"] = variables.objectSet;
+        }
+        return Maybe.of(code `${this.name}: ${this.reusables.snippets.shaclPropertyFromRdf}<${this.type.expression}, ${this.type.schemaType}>(${parameters})`);
     }
     hashStatements({ variables, }) {
         return [
@@ -173,7 +200,7 @@ export class ShaclProperty extends AbstractProperty {
             focusIdentifier: variables.focusIdentifier,
             ignoreRdfType: true,
             propertyName: this.name,
-            propertySchema: code `schema.properties.${this.name}`,
+            propertySchema: this.schemaVariable,
             typeSparqlConstructTriples: this.type.valueSparqlConstructTriplesFunction,
             variablePrefix: variables.variablePrefix,
         }})`);
@@ -188,7 +215,7 @@ export class ShaclProperty extends AbstractProperty {
                 ignoreRdfType: true,
                 preferredLanguages: variables.preferredLanguages,
                 propertyName: this.name,
-                propertySchema: code `schema.properties.${this.name}`,
+                propertySchema: this.schemaVariable,
                 typeSparqlWherePatterns: this.type.valueSparqlWherePatternsFunction,
                 variablePrefix: variables.variablePrefix,
             }})`,
@@ -209,7 +236,9 @@ export class ShaclProperty extends AbstractProperty {
             default:
                 return [];
         }
-        const propertyPath = code `${this.objectType.alias.unsafeCoerce()}.schema.properties.${this.name}.path`;
+        const propertyPath = this.objectType.name
+            .map(() => code `${this.schemaVariable}.path`)
+            .orDefault(this.propertyPathToCode(this.path));
         return [
             code `${variables.resource}.add(${propertyPath}, ${this.type.toRdfResourceValuesExpression({
                 variables: { ...variables, propertyPath },
@@ -255,4 +284,7 @@ __decorate([
 __decorate([
     Memoize()
 ], ShaclProperty.prototype, "jsonSignature", null);
+__decorate([
+    Memoize()
+], ShaclProperty.prototype, "schemaVariable", null);
 //# sourceMappingURL=ShaclProperty.js.map

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

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

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

@@ -1,7 +1,8 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_DateSchema = ({ syntheticNamePrefix }) => conditionalOutput(`${syntheticNamePrefix}DateSchema`, code `\
+export const snippets_DateSchema = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}DateSchema`, code `\
 interface ${syntheticNamePrefix}DateSchema {
-  in?: readonly Date[];
-  kind: "Date" | "DateTime",
+  readonly hasValues?: readonly ${imports.Literal}[];
+  readonly in?: readonly Date[];
+  readonly kind: "Date" | "DateTime",
 }`);
 //# sourceMappingURL=snippets_DateSchema.js.map

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

@@ -1,7 +1,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;
+export const snippets_DefaultValueSchema = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}DefaultValueSchema`, code `\
+interface ${syntheticNamePrefix}DefaultValueSchema<ItemSchemaT> {
+  readonly defaultValue: ${imports.Literal} | ${imports.NamedNode};
   readonly itemType: ItemSchemaT;
   readonly kind: "DefaultValue";
 }`);

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

@@ -1,15 +1,16 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_FromRdfResourceValuesFunction = ({ configuration, imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}FromRdfResourceValuesFunction`, code `\
-export type ${syntheticNamePrefix}FromRdfResourceValuesFunction<T> = (
-  resourceValues: ${imports.Either}<Error, ${imports.Resource}.Values>,
+export type ${syntheticNamePrefix}FromRdfResourceValuesFunction<ValueT, ValueSchemaT> = (
+  resourceValues: ${imports.Resource}.Values,
   options: {
     context?: unknown;
     graph?: Exclude<${imports.Quad_Graph}, ${imports.Variable}>;
+    focusResource: ${imports.Resource};
     ignoreRdfType?: boolean;
-    ${configuration.features.has("ObjectSet") ? code `objectSet?: ${syntheticNamePrefix}ObjectSet;` : ""}
+    ${configuration.features.has("ObjectSet") ? code `objectSet: ${syntheticNamePrefix}ObjectSet;` : ""}
     preferredLanguages?: readonly string[];
     propertyPath: ${syntheticNamePrefix}PropertyPath;
-    resource: ${imports.Resource};
+    schema: ValueSchemaT;
   }
-) => ${imports.Either}<Error, ${imports.Resource}.Values<T>>;`);
+) => ${imports.Either}<Error, ${imports.Resource}.Values<ValueT>>;`);
 //# sourceMappingURL=snippets_FromRdfResourceValuesFunction.js.map

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

@@ -1,6 +1,7 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_IdentifierSchema = ({ syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}IdentifierSchema`, code `\
+export const snippets_IdentifierSchema = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}IdentifierSchema`, code `\
 interface ${syntheticNamePrefix}IdentifierSchema {
+  readonly hasValues?: readonly ${imports.NamedNode}[];
   readonly kind: "Identifier";
 }`);
 //# sourceMappingURL=snippets_IdentifierSchema.js.map

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

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

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

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

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

@@ -0,0 +1,22 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_Lazy = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}Lazy`, code `\
+/**
+ * Type of lazy properties that return a single required value. This is a class instead of an interface so it can be instanceof'd elsewhere.
+ */
+export class ${syntheticNamePrefix}Lazy<PartialT, ResolvedT> {
+  readonly partial: PartialT;
+  private readonly resolver: (partial: PartialT, options?: { preferredLanguages?: readonly string[] }) => Promise<${imports.Either}<Error, ResolvedT>>;
+
+  constructor({ partial, resolver }: {
+    partial: PartialT
+    resolver: (partial: PartialT, options?: { preferredLanguages?: readonly string[] }) => Promise<${imports.Either}<Error, ResolvedT>>,
+  }) {
+    this.partial = partial;
+    this.resolver = resolver;
+  }
+
+  resolve(options?: { preferredLanguages?: readonly string[] }): Promise<${imports.Either}<Error, ResolvedT>> {
+    return this.resolver(this.partial, options);
+  }
+}`);
+//# sourceMappingURL=snippets_Lazy.js.map

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

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

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

@@ -0,0 +1,25 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_LazyOption = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}LazyOption`, code `\
+/**
+ * Type of lazy properties that return a single optional value. This is a class instead of an interface so it can be instanceof'd elsewhere.
+ */
+export class ${syntheticNamePrefix}LazyOption<PartialT, ResolvedT> {
+  readonly partial: ${imports.Maybe}<PartialT>;
+  private readonly resolver: (partial: PartialT, options?: { preferredLanguages?: readonly string[] }) => Promise<${imports.Either}<Error, ResolvedT>>;
+
+  constructor({ partial, resolver }: {
+    partial: ${imports.Maybe}<PartialT>
+    resolver: (partial: PartialT, options?: { preferredLanguages?: readonly string[] }) => Promise<${imports.Either}<Error, ResolvedT>>,
+  }) {
+    this.partial = partial;
+    this.resolver = resolver;
+  }
+
+  async resolve(options?: { preferredLanguages?: readonly string[] }): Promise<${imports.Either}<Error, ${imports.Maybe}<ResolvedT>>> {
+    if (this.partial.isNothing()) {
+      return ${imports.Right}(${imports.Maybe}.empty());
+    }
+    return (await this.resolver(this.partial.unsafeCoerce(), options)).map(${imports.Maybe}.of);
+  }
+}`);
+//# sourceMappingURL=snippets_LazyOption.js.map

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

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

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

@@ -0,0 +1,40 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_LazySet = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}LazySet`, code `\
+/**
+ * Type of lazy properties that return a set of values. This is a class instead of an interface so it can be instanceof'd elsewhere.
+ */
+export class ${syntheticNamePrefix}LazySet<PartialT, ResolvedT> {
+  readonly partials: readonly PartialT[];
+  private readonly resolver: (partials: readonly PartialT[], options?: { preferredLanguages?: readonly string[] }) => Promise<${imports.Either}<Error, readonly ResolvedT[]>>;
+
+  constructor({ partials, resolver }: {
+    partials: readonly PartialT[]
+    resolver: (partials: readonly PartialT[], options?: { preferredLanguages?: readonly string[] }) => Promise<${imports.Either}<Error, readonly ResolvedT[]>>,
+  }) {
+    this.partials = partials;
+    this.resolver = resolver;
+  }
+
+  get length(): number {
+    return this.partials.length;
+  }
+
+  async resolve(options?: { limit?: number; offset?: number; preferredLanguages?: readonly string[] }): Promise<${imports.Either}<Error, readonly ResolvedT[]>> {
+    if (this.partials.length === 0) {
+      return ${imports.Right}([]);
+    }
+
+    const limit = options?.limit ?? Number.MAX_SAFE_INTEGER;
+    if (limit <= 0) {
+      return ${imports.Right}([]);
+    }
+
+    let offset = options?.offset ?? 0;
+    if (offset < 0) {
+      offset = 0;
+    }
+
+    return await this.resolver(this.partials.slice(offset, offset + limit), { preferredLanguages: options?.preferredLanguages });
+  }
+}`);
+//# sourceMappingURL=snippets_LazySet.js.map

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

@@ -1,6 +1,4 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_LiteralFilter = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}LiteralFilter`, code `\
-interface ${syntheticNamePrefix}LiteralFilter extends Omit<${snippets.TermFilter}, "in" | "type"> {
-  readonly in?: readonly ${imports.Literal}[];
-}`);
+type ${syntheticNamePrefix}LiteralFilter = Omit<${snippets.TermFilter}<${imports.Literal}>, "typeIn">;`);
 //# sourceMappingURL=snippets_LiteralFilter.js.map

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

@@ -1,6 +1,7 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_LiteralSchema = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}LiteralSchema`, code `\
 interface ${syntheticNamePrefix}LiteralSchema {
+  readonly hasValues?: readonly ${imports.Literal}[];
   readonly in?: readonly ${imports.Literal}[];
   readonly kind: "Literal";
   readonly languageIn?: readonly string[];

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

@@ -1,6 +1,7 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_NumericSchema = ({ syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}NumericSchema`, code `\
+export const snippets_NumericSchema = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}NumericSchema`, code `\
 interface ${syntheticNamePrefix}NumericSchema<T> {
+  readonly hasValues?: readonly ${imports.Literal}[];
   readonly in?: readonly T[];
   readonly kind: "BigDecimal" | "BigInt" | "Float" | "Int";
 }`);

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

@@ -19,17 +19,15 @@ export function filter(_filter: Filter, _value: ${syntheticNamePrefix}PropertyPa
     if (configuration.features.has("Object.fromRdf")) {
         companionDeclarations.push(code `\
 export const fromRdfResource: ${snippets.FromRdfResourceFunction}<${syntheticNamePrefix}PropertyPath> = ${imports.RdfxResourcePropertyPath}.fromResource;`, code `\
-export const fromRdfResourceValues: ${snippets.FromRdfResourceValuesFunction}<${syntheticNamePrefix}PropertyPath> = (values, options) =>
-  values.chain((values) =>
-    values.chainMap((value) =>
-      value
-        .toResource()
-        .chain((resource) => fromRdfResource(resource, options)),
-    ),
+export const fromRdfResourceValues: ${snippets.FromRdfResourceValuesFunction}<${syntheticNamePrefix}PropertyPath, object> = (values, options) =>
+  values.chainMap((value) =>
+    value
+      .toResource()
+      .chain((resource) => fromRdfResource(resource, options)),
   );`);
     }
     if (configuration.features.has("Object.schema")) {
-        companionDeclarations.push(code `export const schema: Readonly<object> = {}`);
+        companionDeclarations.push(code `export const schema: Readonly<object> = {};`, code `export type Schema = typeof schema;`);
     }
     if (configuration.features.has("Object.toRdf")) {
         companionDeclarations.push(code `\

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

@@ -1,40 +1,40 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_RdfVocabularies = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}RdfVocabularies`, code `\
 namespace ${syntheticNamePrefix}RdfVocabularies {
-  export namespace rdf {
-    export const first = ${imports.dataFactory}.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#first");
-    export const nil = ${imports.dataFactory}.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#nil");
-    export const rest = ${imports.dataFactory}.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#rest");
-    export const subject = ${imports.dataFactory}.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#subject");
-    export const type = ${imports.dataFactory}.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#type");
-  }
+  export const rdf = {
+    first: ${imports.dataFactory}.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#first"),
+    nil: ${imports.dataFactory}.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#nil"),
+    rest: ${imports.dataFactory}.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#rest"),
+    subject: ${imports.dataFactory}.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#subject"),
+    type: ${imports.dataFactory}.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#type"),
+  };
 
-  export namespace rdfs {
-    export const subClassOf = ${imports.dataFactory}.namedNode("http://www.w3.org/2000/01/rdf-schema#subClassOf");
-  }
+  export const rdfs = {
+    subClassOf: ${imports.dataFactory}.namedNode("http://www.w3.org/2000/01/rdf-schema#subClassOf")
+  };
 
-  export namespace xsd {
-    export const boolean = ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#boolean");
-    export const byte = ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#byte");
-    export const date = ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#date");
-    export const dateTime = ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#dateTime");
-    export const decimal = ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#decimal");
-    export const double = ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#double");
-    export const float = ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#float");
-    export const int = ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#int");
-    export const integer = ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#integer");
-    export const long = ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#long");
-    export const negativeInteger = ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#negativeInteger");
-    export const nonNegativeInteger = ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#nonNegativeInteger");
-    export const nonPositiveInteger = ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#nonPositiveInteger");
-    export const positiveInteger = ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#positiveInteger");
-    export const short = ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#short");
-    export const string = ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#string");
-    export const unsignedByte = ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#unsignedByte");
-    export const unsignedInt = ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#unsignedInt");
-    export const unsignedLong = ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#unsignedLong");
-    export const unsignedShort = ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#unsignedShort");
-  }
+  export const xsd = {
+    boolean: ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#boolean"),
+    byte: ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#byte"),
+    date: ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#date"),
+    dateTime: ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#dateTime"),
+    decimal: ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#decimal"),
+    double: ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#double"),
+    float: ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#float"),
+    int: ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#int"),
+    integer: ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#integer"),
+    long: ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#long"),
+    negativeInteger: ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#negativeInteger"),
+    nonNegativeInteger: ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#nonNegativeInteger"),
+    nonPositiveInteger: ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#nonPositiveInteger"),
+    positiveInteger: ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#positiveInteger"),
+    short: ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#short"),
+    string: ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#string"),
+    unsignedByte: ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#unsignedByte"),
+    unsignedInt: ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#unsignedInt"),
+    unsignedLong: ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#unsignedLong"),
+    unsignedShort: ${imports.dataFactory}.namedNode("http://www.w3.org/2001/XMLSchema#unsignedShort")
+  };
 }
 `);
 //# sourceMappingURL=snippets_RdfVocabularies.js.map

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

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_ShaclPropertySchema = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}ShaclPropertySchema`, code `\
-export interface ${syntheticNamePrefix}ShaclPropertySchema<TypeSchemaT = object> {
+export interface ${syntheticNamePrefix}ShaclPropertySchema<TypeSchemaT> {
   readonly kind: "Shacl";
   readonly path: ${snippets.PropertyPath};
   readonly type: TypeSchemaT;

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

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

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

@@ -1,9 +1,9 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_TermFilter = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}TermFilter`, code `\
-interface ${syntheticNamePrefix}TermFilter {
+interface ${syntheticNamePrefix}TermFilter<TermT extends ${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode}> {
   readonly datatypeIn?: readonly ${imports.NamedNode}[];
-  readonly in?: readonly (${imports.Literal} | ${imports.NamedNode})[];
+  readonly in?: readonly Exclude<TermT, ${imports.BlankNode}>[];
   readonly languageIn?: readonly string[];
-  readonly typeIn?: readonly ("BlankNode" | "Literal" | "NamedNode")[];
+  readonly typeIn?: readonly TermT["termType"][];
 }`);
 //# sourceMappingURL=snippets_TermFilter.js.map

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

@@ -1,7 +1,9 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_TermSchema = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}TermSchema`, code `\
-interface ${syntheticNamePrefix}TermSchema {
-  readonly in?: readonly (${imports.Literal} | ${imports.NamedNode})[];
+interface ${syntheticNamePrefix}TermSchema<TermT extends ${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode}> {
+  readonly hasValues?: readonly Exclude<TermT, ${imports.BlankNode}>[];
+  readonly in?: readonly Exclude<TermT, ${imports.BlankNode}>[];
   readonly kind: "Term";
+  readonly types: readonly TermT["termType"][];
 }`);
 //# sourceMappingURL=snippets_TermSchema.js.map

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

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

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

@@ -0,0 +1,6 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_bigDecimalFromRdfResourceValues = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}bigDecimalFromRdfResourceValues`, code `\
+function ${syntheticNamePrefix}bigDecimalFromRdfResourceValues(values: ${imports.Resource}.Values, options: Parameters<${snippets.FromRdfResourceValuesFunction}<${imports.BigDecimal}, ${snippets.NumericSchema}<${imports.BigDecimal}>>>[1]): ${imports.Either}<Error, ${imports.Resource}.Values<${imports.BigDecimal}>> {
+  return ${snippets.termLikeFromRdfResourceValues}(values, options).chain(values => values.chainMap(value => value.toLiteral().chain(${snippets.decodeBigDecimalLiteral})));
+}`);
+//# sourceMappingURL=snippets_bigDecimalFromRdfResourceValues.js.map

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

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

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

@@ -0,0 +1,6 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_bigIntFromRdfResourceValues = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}bigIntFromRdfResourceValues`, code `\
+function ${syntheticNamePrefix}bigIntFromRdfResourceValues<BigintT extends bigint>(values: ${imports.Resource}.Values, options: Parameters<${snippets.FromRdfResourceValuesFunction}<BigintT, ${snippets.NumericSchema}<BigintT>>>[1]): ${imports.Either}<Error, ${imports.Resource}.Values<BigintT>> {
+  return ${snippets.termLikeFromRdfResourceValues}(values, options).chain(values => values.chainMap(value => options.schema.in ? value.toBigInt(options.schema.in) : value.toBigInt() as ${imports.Either}<Error, BigintT>));
+}`);
+//# sourceMappingURL=snippets_bigIntFromRdfResourceValues.js.map

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

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

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

@@ -0,0 +1,6 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_blankNodeFromRdfResourceValues = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}blankNodeFromRdfResourceValues`, code `\
+function ${syntheticNamePrefix}blankNodeFromRdfResourceValues(values: ${imports.Resource}.Values, _options: Parameters<${snippets.FromRdfResourceValuesFunction}<${imports.BlankNode}, ${snippets.BlankNodeSchema}>>[1]): ${imports.Either}<Error, ${imports.Resource}.Values<${imports.BlankNode}>> {
+  return values.chainMap(value => value.toBlankNode());
+}`);
+//# sourceMappingURL=snippets_blankNodeFromRdfResourceValues.js.map

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

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

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

@@ -0,0 +1,6 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_booleanFromRdfResourceValues = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}booleanFromRdfResourceValues`, code `\
+function ${syntheticNamePrefix}booleanFromRdfResourceValues<BooleanT extends boolean>(values: ${imports.Resource}.Values, options: Parameters<${snippets.FromRdfResourceValuesFunction}<BooleanT, ${snippets.BooleanSchema}<BooleanT>>>[1]): ${imports.Either}<Error, ${imports.Resource}.Values<BooleanT>> {
+  return ${snippets.termLikeFromRdfResourceValues}(values, options).chain(values => values.chainMap(value => options.schema.in ? value.toBoolean(options.schema.in) : value.toBoolean() as ${imports.Either}<Error, BooleanT>));
+}`);
+//# sourceMappingURL=snippets_booleanFromRdfResourceValues.js.map

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

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