@shaclmate/compiler 4.0.5 → 4.0.7

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

@@ -1,6 +1,9 @@
+import { Maybe } from "purify-ts";
+import type { TsFeature } from "../../../enums/TsFeature.js";
 import { type Code } from "../ts-poet-wrapper.js";
 export declare function ObjectType_sparqlConstructQueryStringFunctionDeclaration(this: {
+    readonly features: ReadonlySet<TsFeature>;
     readonly filterType: Code;
     readonly staticModuleName: string;
-}): Code;
+}): Maybe<Code>;
 //# sourceMappingURL=ObjectType_sparqlConstructQueryStringFunctionDeclaration.d.ts.map

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

@@ -1,10 +1,14 @@
+import { Maybe } from "purify-ts";
 import { imports } from "../imports.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code } from "../ts-poet-wrapper.js";
 export function ObjectType_sparqlConstructQueryStringFunctionDeclaration() {
-    return code `\
-export function ${syntheticNamePrefix}sparqlConstructQueryString(parameters?: { filter?: ${this.filterType}; ignoreRdfType?: boolean; preferredLanguages?: readonly string[]; subject?: ${imports.NamedNode} | ${imports.Variable}; variablePrefix?: string; } & Omit<${imports.sparqljs}.ConstructQuery, "prefixes" | "queryType" | "type"> & ${imports.sparqljs}.GeneratorOptions): string {
+    if (!this.features.has("sparql")) {
+        return Maybe.empty();
+    }
+    return Maybe.of(code `\
+export function ${syntheticNamePrefix}sparqlConstructQueryString(parameters: Parameters<typeof ${this.staticModuleName}.${syntheticNamePrefix}sparqlConstructQuery>[0] & ${imports.sparqljs}.GeneratorOptions): string {
   return new ${imports.sparqljs}.Generator(parameters).stringify(${this.staticModuleName}.${syntheticNamePrefix}sparqlConstructQuery(parameters));
-}`;
+}`);
 }
 //# sourceMappingURL=ObjectType_sparqlConstructQueryStringFunctionDeclaration.js.map

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

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

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

@@ -0,0 +1,57 @@
+import { rdf, rdfs } from "@tpluscode/rdf-ns-builders";
+import { Maybe } from "purify-ts";
+import { imports } from "../imports.js";
+import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+const variables = {
+    filter: code `parameters.filter`,
+    focusIdentifier: code `parameters.focusIdentifier`,
+    variablePrefix: code `parameters.variablePrefix`,
+};
+export function ObjectType_sparqlConstructTriplesFunctionDeclaration() {
+    if (!this.features.has("sparql")) {
+        return Maybe.empty();
+    }
+    const rdfClassVariable = code `${imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfClass\`)`;
+    const rdfTypeVariable = code `${imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfType\`)`;
+    let triplesVariableDeclarationKeyword = "const";
+    const statements = [];
+    for (const parentObjectType of this.parentObjectTypes) {
+        statements.push(code `triples = triples.concat(${parentObjectType.staticModuleName}.${syntheticNamePrefix}sparqlConstructTriples(${{ filter: variables.filter, focusIdentifier: variables.focusIdentifier, ignoreRdfType: true, variablePrefix: variables.variablePrefix }}));`);
+        triplesVariableDeclarationKeyword = "let";
+    }
+    if (this.fromRdfType.isJust()) {
+        statements.push(code `\
+if (!parameters?.ignoreRdfType) {
+  triples.push(
+    { subject: ${variables.focusIdentifier}, predicate: ${rdfjsTermExpression(rdf.type)}, object: ${rdfTypeVariable} },
+    { subject: ${rdfTypeVariable}, predicate: ${rdfjsTermExpression(rdfs.subClassOf)}, object: ${rdfClassVariable} }
+  );
+}`);
+    }
+    for (const property of this.ownProperties) {
+        if (property.recursive) {
+            continue;
+        }
+        property
+            .sparqlConstructTriplesExpression({
+            variables,
+        })
+            .ifJust((propertyTriples) => {
+            statements.push(code `triples = triples.concat(${propertyTriples});`);
+            triplesVariableDeclarationKeyword = "let";
+        });
+    }
+    return Maybe.of(code `\
+export function ${syntheticNamePrefix}sparqlConstructTriples(${statements.length === 0 ? "_" : ""}parameters: { filter: ${this.filterType} | undefined; focusIdentifier: ${imports.NamedNode} | ${imports.Variable}; ignoreRdfType: boolean;  variablePrefix: string }): readonly ${imports.sparqljs}.Triple[] {
+${statements.length > 0
+        ? joinCode([
+            code `${triplesVariableDeclarationKeyword} triples: ${imports.sparqljs}.Triple[] = [];`,
+            ...statements,
+            code `return triples;`,
+        ])
+        : "return [];"}
+}`);
+}
+//# sourceMappingURL=ObjectType_sparqlConstructTriplesFunctionDeclaration.js.map

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

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

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

@@ -0,0 +1,106 @@
+import { rdf, rdfs } from "@tpluscode/rdf-ns-builders";
+import { Maybe } from "purify-ts";
+import { imports } from "../imports.js";
+import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
+import { snippets } from "../snippets.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+const variables = {
+    filter: code `parameters.filter`,
+    preferredLanguages: code `parameters.preferredLanguages`,
+    focusIdentifier: code `parameters.focusIdentifier`,
+    variablePrefix: code `parameters.variablePrefix`,
+};
+export function ObjectType_sparqlWherePatternsFunctionDeclaration() {
+    if (!this.features.has("sparql")) {
+        return Maybe.empty();
+    }
+    const rdfClassVariable = code `${imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfClass\`)`;
+    const rdfTypeVariable = code `${imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfType\`)`;
+    let patternsVariableDeclarationKeyword = "const";
+    const statements = [];
+    for (const parentObjectType of this.parentObjectTypes) {
+        statements.push(code `\
+patterns = patterns.concat(${parentObjectType.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns(${{ filter: variables.filter, focusIdentifier: variables.focusIdentifier, ignoreRdfType: true, preferredLanguages: variables.preferredLanguages, variablePrefix: variables.variablePrefix }}));`);
+        patternsVariableDeclarationKeyword = "let";
+    }
+    if (this.fromRdfType.isJust()) {
+        const fromRdfTypeVariables = this.fromRdfTypeVariable
+            .toList()
+            .concat(this.descendantFromRdfTypeVariables);
+        statements.push(code `const rdfTypeVariable = ${rdfTypeVariable};`, code `\
+if (!parameters?.ignoreRdfType) {
+  patterns.push(
+    ${fromRdfTypeVariables.length > 1
+            ? code `\
+    {
+      type: "values" as const,
+      values: [${joinCode(fromRdfTypeVariables, { on: "," })}].map((identifier) => {
+        const valuePatternRow: ${imports.sparqljs}.ValuePatternRow = {};
+        valuePatternRow[\`?\${${variables.variablePrefix}}FromRdfType\`] = identifier as ${imports.NamedNode};
+        return valuePatternRow;
+      }),
+    },
+    ${snippets.sparqlInstancesOfPattern}({ rdfType: ${imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}FromRdfType\`), subject: ${variables.focusIdentifier} }),`
+            : code `${snippets.sparqlInstancesOfPattern}({ rdfType: ${fromRdfTypeVariables[0]}, subject: ${variables.focusIdentifier} }),`}
+    {
+      triples: [
+        {
+          subject: ${variables.focusIdentifier},
+          predicate: ${rdfjsTermExpression(rdf.type)},
+          object: rdfTypeVariable
+        }
+      ],
+      type: "bgp" as const
+    },
+    {
+      patterns: [
+        {
+          triples: [
+            {
+              subject: rdfTypeVariable,
+              predicate: {
+                items: [${rdfjsTermExpression(rdfs.subClassOf)}],
+                pathType: "+" as const,
+                type: "path" as const
+              },
+              object: ${rdfClassVariable}
+            }
+          ],
+          type: "bgp" as const
+        }
+      ],
+      type: "optional" as const
+    }
+  );
+}`);
+    }
+    for (const property of this.ownProperties) {
+        if (property.recursive) {
+            continue;
+        }
+        property
+            .sparqlWherePatternsExpression({ variables })
+            .ifJust(({ condition, patterns }) => {
+            const concatStatement = code `patterns = patterns.concat(${patterns});`;
+            if (condition) {
+                statements.push(code `if (${condition}) { ${concatStatement} }`);
+            }
+            else {
+                statements.push(concatStatement);
+            }
+            patternsVariableDeclarationKeyword = "let";
+        });
+    }
+    return Maybe.of(code `\
+export function ${syntheticNamePrefix}sparqlWherePatterns(${statements.length === 0 ? "_" : ""}parameters: { filter: ${this.filterType} | undefined; focusIdentifier: ${imports.NamedNode} | ${imports.Variable}; ignoreRdfType: boolean; preferredLanguages: readonly string[] | undefined; variablePrefix: string }): readonly ${snippets.SparqlPattern}[] {
+${statements.length > 0
+        ? joinCode([
+            code `${patternsVariableDeclarationKeyword} patterns: ${snippets.SparqlPattern}[] = [];`,
+            ...statements,
+            code `return patterns;`,
+        ])
+        : "return [];"}
+}`);
+}
+//# sourceMappingURL=ObjectType_sparqlWherePatternsFunctionDeclarations.js.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_fromJsonFunctionDeclaration.d.ts

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

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_fromJsonFunctionDeclaration.js

@@ -0,0 +1,19 @@
+import { Maybe } from "purify-ts";
+import { code } from "ts-poet";
+import { imports } from "../imports.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+export function ObjectUnionType_fromJsonFunctionDeclaration() {
+    if (!this.features.has("json")) {
+        return Maybe.empty();
+    }
+    return Maybe.of(code `\
+export function ${syntheticNamePrefix}fromJson(json: unknown): ${imports.Either}<${imports.z}.ZodError, ${this.name}> {
+  return ${this.concreteMemberTypes.reduce((expression, memberType) => {
+        const memberTypeExpression = code `(${memberType.staticModuleName}.${syntheticNamePrefix}fromJson(json) as ${imports.Either}<${imports.z}.ZodError, ${this.name}>)`;
+        return expression !== null
+            ? code `${expression}.altLazy(() => ${memberTypeExpression})`
+            : memberTypeExpression;
+    }, null)};
+}`);
+}
+//# sourceMappingURL=ObjectUnionType_fromJsonFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_fromRdfFunctionDeclarations.d.ts

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

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_fromRdfFunctionDeclarations.js

@@ -0,0 +1,20 @@
+import { Maybe } from "purify-ts";
+import { imports } from "../imports.js";
+import { snippets } from "../snippets.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectUnionType_fromRdfFunctionDeclaration() {
+    if (!this.features.has("rdf")) {
+        return Maybe.empty();
+    }
+    return Maybe.of(code `\
+export function ${syntheticNamePrefix}fromRdf(resource: ${imports.Resource}, options?: ${snippets.FromRdfOptions}): ${imports.Either}<Error, ${this.name}> {
+  return ${this.concreteMemberTypes.reduce((expression, memberType) => {
+        const memberTypeExpression = code `(${memberType.staticModuleName}.${syntheticNamePrefix}fromRdf(resource, { ...options, ignoreRdfType: false }) as ${imports.Either}<Error, ${this.name}>)`;
+        return expression !== null
+            ? code `${expression}.altLazy(() => ${memberTypeExpression})`
+            : memberTypeExpression;
+    }, null)};
+}`);
+}
+//# sourceMappingURL=ObjectUnionType_fromRdfFunctionDeclarations.js.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_jsonZodSchemaFunctionDeclaration.d.ts

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

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_jsonZodSchemaFunctionDeclaration.js

@@ -0,0 +1,14 @@
+import { Maybe } from "purify-ts";
+import { code, joinCode } from "ts-poet";
+import { imports } from "../imports.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+export function ObjectUnionType_jsonZodSchemaFunctionDeclaration() {
+    if (!this.features.has("json")) {
+        return Maybe.empty();
+    }
+    return Maybe.of(code `\
+export function ${syntheticNamePrefix}jsonZodSchema() {
+  return ${imports.z}.discriminatedUnion("${this._discriminantProperty.name}", [${joinCode(this.concreteMemberTypes.map((memberType) => memberType.jsonZodSchema({ context: "type" })), { on: ", " })}]);
+}`);
+}
+//# sourceMappingURL=ObjectUnionType_jsonZodSchemaFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_sparqlConstructTriplesFunctionDeclaration.d.ts

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

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_sparqlConstructTriplesFunctionDeclaration.js

@@ -0,0 +1,15 @@
+import { pascalCase } from "change-case";
+import { Maybe } from "purify-ts";
+import { imports } from "../imports.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectUnionType_sparqlConstructTriplesFunctionDeclaration() {
+    if (!this.features.has("sparql")) {
+        return Maybe.empty();
+    }
+    return Maybe.of(code `\
+export function ${syntheticNamePrefix}sparqlConstructTriples({ filter, focusIdentifier, variablePrefix }: { filter: ${this.filterType} | undefined; focusIdentifier: ${imports.NamedNode} | ${imports.Variable}; ignoreRdfType: boolean; variablePrefix: string }): readonly ${imports.sparqljs}.Triple[] {
+  return [${joinCode(this.concreteMemberTypes.map((memberType) => code `...${memberType.staticModuleName}.${syntheticNamePrefix}sparqlConstructTriples({ filter: filter?.on?.${memberType.name}, focusIdentifier, ignoreRdfType: false, variablePrefix: \`\${variablePrefix}${pascalCase(memberType.name)}\` }).concat()`), { on: ", " })}];
+}`);
+}
+//# sourceMappingURL=ObjectUnionType_sparqlConstructTriplesFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_sparqlWherePatternsFunctionDeclaration.d.ts

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

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_sparqlWherePatternsFunctionDeclaration.js

@@ -0,0 +1,35 @@
+import { pascalCase } from "change-case";
+import { Maybe } from "purify-ts";
+import { imports } from "../imports.js";
+import { snippets } from "../snippets.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
+export function ObjectUnionType_sparqlWherePatternsFunctionDeclaration() {
+    if (!this.features.has("sparql")) {
+        return Maybe.empty();
+    }
+    return Maybe.of(code `\
+export function ${syntheticNamePrefix}sparqlWherePatterns({ filter, focusIdentifier, preferredLanguages, variablePrefix }: { filter: ${this.filterType} | undefined; focusIdentifier: ${imports.NamedNode} | ${imports.Variable}; ignoreRdfType: boolean; preferredLanguages: readonly string[] | undefined; variablePrefix: string }): readonly ${snippets.SparqlPattern}[] {
+${joinCode([
+        code `let patterns: ${snippets.SparqlPattern}[] = [];`,
+        code `\
+if (focusIdentifier.termType === "Variable") {
+  patterns = patterns.concat(${this.identifierType.sparqlWherePatternsFunction}({
+      filter: filter?.${syntheticNamePrefix}identifier,
+      ignoreRdfType: false,
+      preferredLanguages,
+      propertyPatterns: [],
+      schema: ${this.identifierType.schema},
+      valueVariable: focusIdentifier,
+      variablePrefix,
+  }));
+}`,
+        code `patterns.push({ patterns: [${joinCode(this.concreteMemberTypes.map((memberType) => code `${{
+            patterns: code `${memberType.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns({ filter: filter?.on?.${memberType.name}, focusIdentifier, ignoreRdfType: false, preferredLanguages, variablePrefix: \`\${variablePrefix}${pascalCase(memberType.name)}\` }).concat()`,
+            type: literalOf("group"),
+        }}`), { on: ", " })}], type: "union" });`,
+        code `return patterns;`,
+    ])}
+}`);
+}
+//# sourceMappingURL=ObjectUnionType_sparqlWherePatternsFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_toJsonFunctionDeclaration.d.ts

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

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_toJsonFunctionDeclaration.js

@@ -0,0 +1,26 @@
+import { Maybe } from "purify-ts";
+import { code, joinCode } from "ts-poet";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+export function ObjectUnionType_toJsonFunctionDeclaration() {
+    if (!this.features.has("json")) {
+        return Maybe.empty();
+    }
+    return Maybe.of(code `\
+export function ${syntheticNamePrefix}toJson(${this.thisVariable}: ${this.name}): ${this.jsonType().name} {
+${joinCode(this.concreteMemberTypes
+        .map((memberType) => {
+        let returnExpression;
+        switch (memberType.declarationType) {
+            case "class":
+                returnExpression = code `${this.thisVariable}.${syntheticNamePrefix}toJson()`;
+                break;
+            case "interface":
+                returnExpression = code `${memberType.staticModuleName}.${syntheticNamePrefix}toJson(${this.thisVariable})`;
+                break;
+        }
+        return code `if (${memberType.staticModuleName}.is${memberType.name}(${this.thisVariable})) { return ${returnExpression}; }`;
+    })
+        .concat(code `throw new Error("unrecognized type");`))}
+}`);
+}
+//# sourceMappingURL=ObjectUnionType_toJsonFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_toRdfFunctionDeclarations.d.ts

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

package/dist/generators/ts/_ObjectUnionType/{ObjectUnionType_rdfFunctionDeclarations.js → ObjectUnionType_toRdfFunctionDeclarations.js}

@@ -1,29 +1,12 @@
+import { Maybe } from "purify-ts";
 import { codeEquals } from "../codeEquals.js";
 import { imports } from "../imports.js";
-import { snippets } from "../snippets.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-function ObjectUnionType_fromRdfFunctionDeclaration() {
-    return code `\
-export function ${syntheticNamePrefix}fromRdf(resource: ${imports.Resource}, options?: ${snippets.FromRdfOptions}): ${imports.Either}<Error, ${this.name}> {
-  return ${this.concreteMemberTypes.reduce((expression, memberType) => {
-        const memberTypeExpression = code `(${memberType.staticModuleName}.${syntheticNamePrefix}fromRdf(resource, { ...options, ignoreRdfType: false }) as ${imports.Either}<Error, ${this.name}>)`;
-        return expression !== null
-            ? code `${expression}.altLazy(() => ${memberTypeExpression})`
-            : memberTypeExpression;
-    }, null)};
-}`;
-}
-export function rdfFunctionDeclarations() {
+export function ObjectUnionType_toRdfFunctionDeclaration() {
     if (!this.features.has("rdf")) {
-        return [];
+        return Maybe.empty();
     }
-    return [
-        ObjectUnionType_fromRdfFunctionDeclaration.bind(this)(),
-        ObjectUnionType_toRdfFunctionDeclaration.bind(this)(),
-    ];
-}
-function ObjectUnionType_toRdfFunctionDeclaration() {
     const parametersVariable = "_parameters";
     const returnType = () => {
         let returnType;
@@ -39,7 +22,7 @@ function ObjectUnionType_toRdfFunctionDeclaration() {
         // The types agree
         return returnType;
     };
-    return code `\
+    return Maybe.of(code `\
 export function ${syntheticNamePrefix}toRdf(${this.thisVariable}: ${this.name}, ${parametersVariable}?: { graph?: Exclude<${imports.Quad_Graph}, ${imports.Variable}>, resourceSet?: ${imports.ResourceSet} }): ${returnType()} {
 ${joinCode(this.concreteMemberTypes
         .map((memberType) => {
@@ -55,6 +38,6 @@ ${joinCode(this.concreteMemberTypes
         return code `if (${memberType.staticModuleName}.is${memberType.name}(${this.thisVariable})) { return ${returnExpression}; }`;
     })
         .concat(code `throw new Error("unrecognized type");`))}
-}`;
+}`);
 }
-//# sourceMappingURL=ObjectUnionType_rdfFunctionDeclarations.js.map
+//# sourceMappingURL=ObjectUnionType_toRdfFunctionDeclarations.js.map

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

@@ -7,18 +7,18 @@ export const snippets_LazyObject = conditionalOutput(`${syntheticNamePrefix}Lazy
  */
 export class ${syntheticNamePrefix}LazyObject<ObjectIdentifierT extends ${imports.BlankNode} | ${imports.NamedNode}, PartialObjectT extends { ${syntheticNamePrefix}identifier: ObjectIdentifierT }, ResolvedObjectT extends { ${syntheticNamePrefix}identifier: ObjectIdentifierT }> {
   readonly partial: PartialObjectT;
-  private readonly resolver: (identifier: ObjectIdentifierT) => Promise<${imports.Either}<Error, ResolvedObjectT>>;
+  private readonly resolver: (identifier: ObjectIdentifierT, options?: { preferredLanguages?: readonly string[] }) => Promise<${imports.Either}<Error, ResolvedObjectT>>;
 
   constructor({ partial, resolver }: {
     partial: PartialObjectT
-    resolver: (identifier: ObjectIdentifierT) => Promise<${imports.Either}<Error, ResolvedObjectT>>,
+    resolver: (identifier: ObjectIdentifierT, options?: { preferredLanguages?: readonly string[] }) => Promise<${imports.Either}<Error, ResolvedObjectT>>,
   }) {
     this.partial = partial;
     this.resolver = resolver;
   }
 
-  resolve(): Promise<${imports.Either}<Error, ResolvedObjectT>> {
-    return this.resolver(this.partial.${syntheticNamePrefix}identifier);
+  resolve(options?: { preferredLanguages?: readonly string[] }): Promise<${imports.Either}<Error, ResolvedObjectT>> {
+    return this.resolver(this.partial.${syntheticNamePrefix}identifier, options);
   }
 }`);
 //# sourceMappingURL=snippets_LazyObject.js.map

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

@@ -7,21 +7,21 @@ export const snippets_LazyObjectOption = conditionalOutput(`${syntheticNamePrefi
  */
 export class ${syntheticNamePrefix}LazyObjectOption<ObjectIdentifierT extends ${imports.BlankNode} | ${imports.NamedNode}, PartialObjectT extends { ${syntheticNamePrefix}identifier: ObjectIdentifierT }, ResolvedObjectT extends { ${syntheticNamePrefix}identifier: ObjectIdentifierT }> {
   readonly partial: ${imports.Maybe}<PartialObjectT>;
-  private readonly resolver: (identifier: ObjectIdentifierT) => Promise<${imports.Either}<Error, ResolvedObjectT>>;
+  private readonly resolver: (identifier: ObjectIdentifierT, options?: { preferredLanguages?: readonly string[] }) => Promise<${imports.Either}<Error, ResolvedObjectT>>;
 
   constructor({ partial, resolver }: {
     partial: ${imports.Maybe}<PartialObjectT>
-    resolver: (identifier: ObjectIdentifierT) => Promise<${imports.Either}<Error, ResolvedObjectT>>,
+    resolver: (identifier: ObjectIdentifierT, options?: { preferredLanguages?: readonly string[] }) => Promise<${imports.Either}<Error, ResolvedObjectT>>,
   }) {
     this.partial = partial;
     this.resolver = resolver;
   }
 
-  async resolve(): Promise<${imports.Either}<Error, ${imports.Maybe}<ResolvedObjectT>>> {
+  async resolve(options?: { preferredLanguages?: readonly string[] }): Promise<${imports.Either}<Error, ${imports.Maybe}<ResolvedObjectT>>> {
     if (this.partial.isNothing()) {
       return ${imports.Right}(${imports.Maybe}.empty());
     }
-    return (await this.resolver(this.partial.unsafeCoerce().${syntheticNamePrefix}identifier)).map(${imports.Maybe}.of);
+    return (await this.resolver(this.partial.unsafeCoerce().${syntheticNamePrefix}identifier, options)).map(${imports.Maybe}.of);
   }
 }`);
 //# sourceMappingURL=snippets_LazyObjectOption.js.map

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

@@ -7,11 +7,11 @@ export const snippets_LazyObjectSet = conditionalOutput(`${syntheticNamePrefix}L
  */
 export class ${syntheticNamePrefix}LazyObjectSet<ObjectIdentifierT extends ${imports.BlankNode} | ${imports.NamedNode}, PartialObjectT extends { ${syntheticNamePrefix}identifier: ObjectIdentifierT }, ResolvedObjectT extends { ${syntheticNamePrefix}identifier: ObjectIdentifierT }> {
   readonly partials: readonly PartialObjectT[];
-  private readonly resolver: (identifiers: readonly ObjectIdentifierT[]) => Promise<${imports.Either}<Error, readonly ResolvedObjectT[]>>;
+  private readonly resolver: (identifiers: readonly ObjectIdentifierT[], options?: { preferredLanguages?: readonly string[] }) => Promise<${imports.Either}<Error, readonly ResolvedObjectT[]>>;
 
   constructor({ partials, resolver }: {
     partials: readonly PartialObjectT[]
-    resolver: (identifiers: readonly ObjectIdentifierT[]) => Promise<${imports.Either}<Error, readonly ResolvedObjectT[]>>,
+    resolver: (identifiers: readonly ObjectIdentifierT[], options?: { preferredLanguages?: readonly string[] }) => Promise<${imports.Either}<Error, readonly ResolvedObjectT[]>>,
   }) {
     this.partials = partials;
     this.resolver = resolver;
@@ -21,7 +21,7 @@ export class ${syntheticNamePrefix}LazyObjectSet<ObjectIdentifierT extends ${imp
     return this.partials.length;
   }
 
-  async resolve(options?: { limit?: number; offset?: number }): Promise<${imports.Either}<Error, readonly ResolvedObjectT[]>> {
+  async resolve(options?: { limit?: number; offset?: number; preferredLanguages?: readonly string[] }): Promise<${imports.Either}<Error, readonly ResolvedObjectT[]>> {
     if (this.partials.length === 0) {
       return ${imports.Right}([]);
     }
@@ -36,7 +36,7 @@ export class ${syntheticNamePrefix}LazyObjectSet<ObjectIdentifierT extends ${imp
       offset = 0;
     }
 
-    return await this.resolver(this.partials.slice(offset, offset + limit).map(partial => partial.${syntheticNamePrefix}identifier));
+    return await this.resolver(this.partials.slice(offset, offset + limit).map(partial => partial.${syntheticNamePrefix}identifier), { preferredLanguages: options?.preferredLanguages });
   }
 }`);
 //# sourceMappingURL=snippets_LazyObjectSet.js.map

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

@@ -3,8 +3,8 @@ import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_SparqlConstructTriplesFunctionParameters = conditionalOutput(`${syntheticNamePrefix}SparqlConstructTriplesFunctionParameters`, code `\
 type ${syntheticNamePrefix}SparqlConstructTriplesFunctionParameters<FilterT, SchemaT> = Readonly<{
-  filter?: FilterT;
-  ignoreRdfType?: boolean;
+  filter: FilterT | undefined;
+  ignoreRdfType: boolean;
   schema: SchemaT;
   valueVariable: ${imports.Variable};
   variablePrefix: string;

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

@@ -4,9 +4,9 @@ import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 import { snippets_SparqlPattern } from "./snippets_SparqlPattern.js";
 export const snippets_SparqlWherePatternsFunctionParameters = conditionalOutput(`${syntheticNamePrefix}SparqlWherePatternsFunctionParameters`, code `\
 type ${syntheticNamePrefix}SparqlWherePatternsFunctionParameters<FilterT, SchemaT> = Readonly<{
-  filter?: FilterT;
-  ignoreRdfType?: boolean;
-  preferredLanguages?: readonly string[];
+  filter: FilterT | undefined;
+  ignoreRdfType: boolean;
+  preferredLanguages: readonly string[] | undefined;
   propertyPatterns: readonly ${snippets_SparqlPattern}[];
   schema: SchemaT;
   valueVariable: ${imports.Variable};

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

@@ -17,6 +17,6 @@ const ${syntheticNamePrefix}booleanSparqlWherePatterns: ${snippets_SparqlWherePa
       }
     }
 
-    return ${snippets_termSchemaSparqlPatterns}({ filterPatterns, valueVariable, ...otherParameters });
+    return ${snippets_termSchemaSparqlPatterns}({ ...otherParameters, filterPatterns, valueVariable });
   }`);
 //# sourceMappingURL=snippets_booleanSparqlWherePatterns.js.map

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

@@ -74,6 +74,6 @@ const ${syntheticNamePrefix}dateSparqlWherePatterns: ${snippets_SparqlWherePatte
       }
     }
 
-    return ${snippets_termSchemaSparqlPatterns}({ filterPatterns, schema, valueVariable, ...otherParameters });
+    return ${snippets_termSchemaSparqlPatterns}({ ...otherParameters, filterPatterns, schema, valueVariable });
   }`);
 //# sourceMappingURL=snippets_dateSparqlWherePatterns.js.map

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

@@ -6,7 +6,7 @@ import { snippets_SparqlWherePatternsFunction } from "./snippets_SparqlWherePatt
 export const snippets_defaultValueSparqlWherePatterns = conditionalOutput(`${syntheticNamePrefix}defaultValueSparqlWherePatterns`, code `\
 function ${syntheticNamePrefix}defaultValueSparqlWherePatterns<ItemFilterT, ItemSchemaT>(itemSparqlWherePatternsFunction: ${snippets_SparqlWherePatternsFunction}<ItemFilterT, ItemSchemaT>): ${snippets_SparqlWherePatternsFunction}<ItemFilterT, ${snippets_DefaultValueSchema}<ItemSchemaT>> {  
   return ({ schema, ...otherParameters }) => {
-    const [itemSparqlWherePatterns, liftSparqlPatterns] = ${snippets_liftSparqlPatterns}(itemSparqlWherePatternsFunction({ schema: schema.item(), ...otherParameters }));
+    const [itemSparqlWherePatterns, liftSparqlPatterns] = ${snippets_liftSparqlPatterns}(itemSparqlWherePatternsFunction({ ...otherParameters, schema: schema.item() }));
     return [{ patterns: itemSparqlWherePatterns.concat(), type: "optional" }, ...liftSparqlPatterns];
   }
 }`);

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

@@ -15,6 +15,6 @@ const ${syntheticNamePrefix}iriSparqlWherePatterns: ${snippets_SparqlWherePatter
       filterPatterns.push(${snippets_sparqlValueInPattern}({ lift: true, valueVariable, valueIn: filter.in }));
     }
 
-    return ${snippets_termSchemaSparqlPatterns}({ filterPatterns, valueVariable, ...otherParameters });
+    return ${snippets_termSchemaSparqlPatterns}({ ...otherParameters, filterPatterns, valueVariable });
   };`);
 //# sourceMappingURL=snippets_iriSparqlWherePatterns.js.map

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

@@ -7,16 +7,16 @@ import { snippets_RdfVocabularies } from "./snippets_RdfVocabularies.js";
 import { snippets_SparqlConstructTriplesFunction } from "./snippets_SparqlConstructTriplesFunction.js";
 export const snippets_listSparqlConstructTriples = conditionalOutput(`${syntheticNamePrefix}listSparqlConstructTriples`, code `\
 function ${syntheticNamePrefix}listSparqlConstructTriples<ItemFilterT, ItemSchemaT>(itemSparqlConstructTriplesFunction: ${snippets_SparqlConstructTriplesFunction}<ItemFilterT, ItemSchemaT>): ${snippets_SparqlConstructTriplesFunction}<${snippets_CollectionFilter}<ItemFilterT>, ${snippets_CollectionSchema}<ItemSchemaT>> {
-  return ({ filter, schema, valueVariable: listVariable, ...otherParameters }) => {
+  return ({ filter, schema, valueVariable: listVariable, variablePrefix: variablePrefixPrefix }) => {
     let triples: ${imports.sparqljs}.Triple[] = [];
-    const variable = (suffix: string) => ${imports.dataFactory}.variable!(\`\${otherParameters.variablePrefix}\${suffix}\`);
-    const variablePrefix = (suffix: string) => \`\${otherParameters.variablePrefix}\${suffix}\`;
+    const variable = (suffix: string) => ${imports.dataFactory}.variable!(\`\${variablePrefixPrefix}\${suffix}\`);
+    const variablePrefix = (suffix: string) => \`\${variablePrefixPrefix}\${suffix}\`;
 
     {
       // ?list rdf:first ?item0
       const item0Variable = variable("Item0");
       triples.push({ subject: listVariable, predicate: ${snippets_RdfVocabularies}.rdf.first, object: item0Variable });
-      triples = triples.concat(itemSparqlConstructTriplesFunction({ filter, schema: schema.item(), valueVariable: item0Variable, variablePrefix: variablePrefix("Item0") }));
+      triples = triples.concat(itemSparqlConstructTriplesFunction({ filter, ignoreRdfType: false, schema: schema.item(), valueVariable: item0Variable, variablePrefix: variablePrefix("Item0") }));
     }
 
     {
@@ -31,7 +31,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, schema: schema.item(), valueVariable: itemNVariable, variablePrefix: variablePrefix("ItemN") }));
+      triples = triples.concat(itemSparqlConstructTriplesFunction({ filter, ignoreRdfType: false, schema: schema.item(), valueVariable: itemNVariable, variablePrefix: variablePrefix("ItemN") }));
     }
 
     // ?restN rdf:rest ?restNBasic to get the rdf:rest statement in the CONSTRUCT