@shaclmate/compiler 4.0.40 → 4.0.42

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

@@ -0,0 +1,14 @@
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectType_toJsonFunctionExpression() {
+    return code `\
+((${this.thisVariable}) => JSON.parse(JSON.stringify({ ${joinCode(this.properties.flatMap((property) => property
+        .toJsonInitializer({
+        variables: {
+            value: property.accessExpression({
+                variables: { object: this.thisVariable },
+            }),
+        },
+    })
+        .toList()), { on: "," })} } satisfies ${this.jsonType().expression})))`;
+}
+//# sourceMappingURL=ObjectType_toJsonFunctionExpression.js.map

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

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

package/dist/generators/ts/_ObjectType/{ObjectType_toRdfResourceFunctionDeclaration.js → ObjectType_toRdfResourceFunctionExpression.js}

@@ -1,11 +1,7 @@
 import { rdf } from "@tpluscode/rdf-ns-builders";
-import { Maybe } from "purify-ts";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectType_toRdfResourceFunctionDeclaration() {
-    if (!this.configuration.features.has("Object.toRdf")) {
-        return Maybe.empty();
-    }
-    const statements = this.parentObjectTypes.map((parentObjectType) => code `${parentObjectType.alias.unsafeCoerce()}._toRdfResource({ ...parameters, ignoreRdfType: true });`);
+export function ObjectType_toRdfResourceFunctionExpression() {
+    const statements = [];
     if (this.toRdfTypes.length > 0) {
         statements.push(code `if (!${variables.ignoreRdfType}) { ${joinCode(this.toRdfTypes.map((toRdfType) => code `${variables.resource}.add(${this.rdfjsTermExpression(rdf.type)}, ${this.reusables.imports.dataFactory}.namedNode("${toRdfType.value}"), ${variables.graph});`), { on: " " })} }`);
     }
@@ -22,12 +18,10 @@ export function ObjectType_toRdfResourceFunctionDeclaration() {
         }));
     }
     statements.push(code `return ${variables.resource};`);
-    return Maybe.of(code `\
-export const _toRdfResource: ${this.reusables.snippets._ToRdfResourceFunction}<${this.identifierTypeAlias}, ${this.expression}> = (parameters) => {
-${joinCode(statements)}
-}
-
-export const toRdfResource = ${this.reusables.snippets.wrap_ToRdfResourceFunction}(_toRdfResource);`);
+    return code `\
+((parameters) => {
+  ${joinCode(statements)}
+})`;
 }
 const variables = {
     ignoreRdfType: code `parameters.ignoreRdfType`,
@@ -36,4 +30,4 @@ const variables = {
     resource: code `parameters.resource`,
     resourceSet: code `parameters.resourceSet`,
 };
-//# sourceMappingURL=ObjectType_toRdfResourceFunctionDeclaration.js.map
+//# sourceMappingURL=ObjectType_toRdfResourceFunctionExpression.js.map

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

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

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

@@ -0,0 +1,7 @@
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectType_toStringFunctionExpression() {
+    return this.name
+        .map((name) => code `((${this.thisVariable}) => \`${name}(\${JSON.stringify(toStringRecord(${this.thisVariable}))})\`)`)
+        .orDefault(code `((${this.thisVariable}) => JSON.stringify(${this.toStringRecordExpression({ variables: { value: this.thisVariable } })}))`);
+}
+//# sourceMappingURL=ObjectType_toStringFunctionExpression.js.map

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

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

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

@@ -0,0 +1,5 @@
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectType_toStringRecordFunctionExpression() {
+    return code `((${this.thisVariable}) => ${this.toStringRecordExpression({ variables: { value: this.thisVariable } })})`;
+}
+//# sourceMappingURL=ObjectType_toStringRecordFunctionExpression.js.map

package/dist/generators/ts/_ObjectType/{ObjectType_valueSparqlConstructTriplesFunctionDeclaration.d.ts → ObjectType_valueSparqlConstructTriplesFunctionExpression.d.ts}

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

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

@@ -0,0 +1,8 @@
+import { code } from "../ts-poet-wrapper.js";
+import { ObjectType_focusSparqlConstructTriplesFunctionExpression } from "./ObjectType_focusSparqlConstructTriplesFunctionExpression.js";
+export function ObjectType_valueSparqlConstructTriplesFunctionExpression() {
+    return code `\
+(({ filter, ignoreRdfType, valueVariable, variablePrefix }) =>
+  ${this.name.map((name) => code `${name}.focusSparqlConstructTriples`).orDefaultLazy(() => ObjectType_focusSparqlConstructTriplesFunctionExpression.call(this))}({ filter, focusIdentifier: valueVariable, ignoreRdfType, variablePrefix }))`;
+}
+//# sourceMappingURL=ObjectType_valueSparqlConstructTriplesFunctionExpression.js.map

package/dist/generators/ts/_ObjectType/{ObjectType_valueSparqlWherePatternsFunctionDeclaration.d.ts → ObjectType_valueSparqlWherePatternsFunctionExpression.d.ts}

@@ -1,5 +1,4 @@
-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
+export declare function ObjectType_valueSparqlWherePatternsFunctionExpression(this: ObjectType): Code;
+//# sourceMappingURL=ObjectType_valueSparqlWherePatternsFunctionExpression.d.ts.map

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

@@ -0,0 +1,10 @@
+import { code } from "../ts-poet-wrapper.js";
+import { ObjectType_focusSparqlWherePatternsFunctionExpression } from "./ObjectType_focusSparqlWherePatternsFunctionExpression.js";
+export function ObjectType_valueSparqlWherePatternsFunctionExpression() {
+    return code `\
+(({ filter, ignoreRdfType, preferredLanguages, propertyPatterns, valueVariable, variablePrefix }) =>
+  (propertyPatterns as readonly ${this.reusables.snippets.SparqlPattern}[]).concat(
+    ${this.name.map((name) => code `${name}.focusSparqlWherePatterns`).orDefaultLazy(() => ObjectType_focusSparqlWherePatternsFunctionExpression.call(this))}({ filter, focusIdentifier: valueVariable, ignoreRdfType, preferredLanguages, variablePrefix })
+))`;
+}
+//# sourceMappingURL=ObjectType_valueSparqlWherePatternsFunctionExpression.js.map

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

@@ -21,16 +21,23 @@ export declare class ShaclProperty<TypeT extends Type> extends AbstractProperty<
         path: PropertyPath;
         recursive: boolean;
     } & ConstructorParameters<typeof AbstractProperty<TypeT>>[0]);
-    get constructorParameter(): Maybe<Code>;
+    get constructorParameter(): Maybe<{
+        hasQuestionToken: boolean;
+        signature: Code;
+    }>;
     get declaration(): Code;
     get filterProperty(): Maybe<{
         name: string;
         type: Code;
     }>;
     get graphqlField(): AbstractProperty<TypeT>["graphqlField"];
+    get hashFunctionParameter(): Code;
     get jsonSchema(): AbstractProperty<TypeT>["jsonSchema"];
     get jsonSignature(): Maybe<Code>;
-    protected get schemaInitializers(): readonly Code[];
+    get schema(): Maybe<Code>;
+    get schemaType(): Maybe<Code>;
+    private get schemaVariable();
+    private get typeSchemaVariable();
     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/_ObjectType/ShaclProperty.js

@@ -31,31 +31,36 @@ 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 typeNames = [];
+        const typeExpressions = [];
         for (const type of conversionFunction.sourceTypes) {
-            if (type.typeof === "undefined") {
+            if (type.jsType.typeof === "undefined") {
                 hasQuestionToken = true;
             }
             else {
-                typeNames.push(code `${type.expression}`);
+                typeExpressions.push(code `${type.expression}`);
             }
         }
-        return Maybe.of(code `readonly ${this.name}${hasQuestionToken ? "?" : ""}: ${joinCode(typeNames, { 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({
@@ -71,9 +76,12 @@ export class ShaclProperty extends AbstractProperty {
             description: this.comment.map(JSON.stringify),
             name: this.name,
             resolve: code `(source, ${argsVariable}) => ${this.type.graphqlResolveExpression({ variables: { args: argsVariable, value: code `source.${this.name}` } })}`,
-            type: this.type.graphqlType.name,
+            type: this.type.graphqlType.expression,
         });
     }
+    get hashFunctionParameter() {
+        return this.declaration;
+    }
     get jsonSchema() {
         let schema = this.type.jsonSchema({
             context: "property",
@@ -95,22 +103,41 @@ export class ShaclProperty extends AbstractProperty {
     }
     get jsonSignature() {
         const typeJsonType = this.type.jsonType();
-        return Maybe.of(code `${!this.mutable ? "readonly " : ""}${this.name}${typeJsonType.optional ? "?" : ""}: ${typeJsonType.requiredName}`);
+        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 `\