@shaclmate/compiler 4.0.5 → 4.0.7

package/dist/generators/ts/AbstractLazyObjectType.js

@@ -59,10 +59,10 @@ export class AbstractLazyObjectType extends AbstractType {
         }}`;
     }
     get sparqlConstructTriplesFunction() {
-        return code `(({ schema, ...otherParameters }) => ${this.partialType.sparqlConstructTriplesFunction}({ schema: schema.partial(), ...otherParameters }))`;
+        return code `(({ schema, ...otherParameters }) => ${this.partialType.sparqlConstructTriplesFunction}({ ...otherParameters, schema: schema.partial() }))`;
     }
     get sparqlWherePatternsFunction() {
-        return code `(({ schema, ...otherParameters }) => ${this.partialType.sparqlWherePatternsFunction}({ schema: schema.partial(), ...otherParameters }))`;
+        return code `(({ schema, ...otherParameters }) => ${this.partialType.sparqlWherePatternsFunction}({ ...otherParameters, schema: schema.partial() }))`;
     }
     get schemaObject() {
         return {

package/dist/generators/ts/AbstractType.d.ts

@@ -69,23 +69,23 @@ export declare abstract class AbstractType {
      * A SparqlConstructTriplesFunction (reference or declaration) that returns an array of sparqljs.Triple's for a property of this type.
      *
      * The function takes a parameters object (type: SparqlConstructTriplesFunctionParameters) with the following parameters:
-     * - filter?: an instance of filterType
-     * - ignoreRdfType?: boolean
+     * - filter: an instance of filterType | undefined
+     * - ignoreRdfType: boolean
      * - schema: instance of this.schemaType
      * - valueVariable: rdfjs.Variable of the value of this type
-     * - variablePrefix: prefix to use for new variables
+     * - variablePrefix: string prefix to use for new variables
      */
     abstract readonly sparqlConstructTriplesFunction: Code;
     /**
      * A SparqlWherePatternsFunction (reference or declaration) that returns an array of SparqlPattern's for a property of this type.
      *
      * The function takes a parameters object (type: SparqlWherePatternsFunctionParameters) with the following parameters:
-     * - filter?: an instance of filterType
-     * - preferredLanguages: array of preferred language code (strings); may be empty
+     * - filter: an instance of filterType | undefined
+     * - preferredLanguages: array of preferred language code (strings) | undefined
      * - propertyPatterns: array of sparqljs.Pattern's for the property; may be empty
      * - schema: instance of this.schemaType
      * - valueVariable: rdfjs.Variable of the value of this type
-     * - variablePrefix: prefix to use for new variables
+     * - variablePrefix: string prefix to use for new variables
      */
     abstract readonly sparqlWherePatternsFunction: Code;
     /**

package/dist/generators/ts/LazyObjectOptionType.js

@@ -75,7 +75,7 @@ export class LazyObjectOptionType extends Super {
     }
     fromRdfExpression(parameters) {
         const { variables } = parameters;
-        return code `${this.partialType.fromRdfExpression(parameters)}.map(values => values.map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: (identifier) => ${variables.objectSet}.${this.resolveType.itemType.objectSetMethodNames.object}(identifier) })))`;
+        return code `${this.partialType.fromRdfExpression(parameters)}.map(values => values.map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: (identifier, options) => ${variables.objectSet}.${this.resolveType.itemType.objectSetMethodNames.object}(identifier, options) })))`;
     }
     graphqlResolveExpression({ variables, }) {
         return code `${variables.value}.resolve().then(either => either.unsafeCoerce().extractNullable())`;

package/dist/generators/ts/LazyObjectSetType.js

@@ -66,7 +66,7 @@ export class LazyObjectSetType extends AbstractLazyObjectType {
     }
     fromRdfExpression(parameters) {
         const { variables } = parameters;
-        return code `${this.partialType.fromRdfExpression(parameters)}.map(values => values.map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: (identifiers) => ${variables.objectSet}.${this.resolveType.itemType.objectSetMethodNames.objects}({ identifiers }) })))`;
+        return code `${this.partialType.fromRdfExpression(parameters)}.map(values => values.map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: (identifiers, options) => ${variables.objectSet}.${this.resolveType.itemType.objectSetMethodNames.objects}({ identifiers, ...options }) })))`;
     }
     graphqlResolveExpression({ variables, }) {
         return code `(${variables.value}.resolve({ limit: ${variables.args}.limit, offset: ${variables.args}.offset })).then(either => either.unsafeCoerce())`;

package/dist/generators/ts/LazyObjectType.js

@@ -50,7 +50,7 @@ export class LazyObjectType extends AbstractLazyObjectType {
     }
     fromRdfExpression(parameters) {
         const { variables } = parameters;
-        return code `${this.partialType.fromRdfExpression(parameters)}.map(values => values.map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: (identifier) => ${variables.objectSet}.${this.resolveType.objectSetMethodNames.object}(identifier) })))`;
+        return code `${this.partialType.fromRdfExpression(parameters)}.map(values => values.map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: (identifier, options) => ${variables.objectSet}.${this.resolveType.objectSetMethodNames.object}(identifier, options) })))`;
     }
     graphqlResolveExpression({ variables, }) {
         return code `${variables.value}.resolve().then(either => either.unsafeCoerce())`;

package/dist/generators/ts/ObjectType.js

@@ -16,17 +16,26 @@ import { ObjectType_createFunctionDeclaration } from "./_ObjectType/ObjectType_c
 import { ObjectType_equalsFunctionOrMethodDeclaration } from "./_ObjectType/ObjectType_equalsFunctionOrMethodDeclaration.js";
 import { ObjectType_filterFunctionDeclaration } from "./_ObjectType/ObjectType_filterFunctionDeclaration.js";
 import { ObjectType_filterTypeDeclaration } from "./_ObjectType/ObjectType_filterTypeDeclaration.js";
+import { ObjectType_fromJsonFunctionDeclarations } from "./_ObjectType/ObjectType_fromJsonFunctionDeclarations.js";
+import { ObjectType_fromRdfFunctionDeclaration } from "./_ObjectType/ObjectType_fromRdfFunctionDeclaration.js";
 import { ObjectType_fromRdfTypeVariableStatement } from "./_ObjectType/ObjectType_fromRdfTypeVariableStatement.js";
 import { ObjectType_graphqlTypeVariableStatement } from "./_ObjectType/ObjectType_graphqlTypeVariableStatement.js";
 import { ObjectType_hashFunctionOrMethodDeclarations } from "./_ObjectType/ObjectType_hashFunctionOrMethodDeclarations.js";
 import { ObjectType_interfaceDeclaration } from "./_ObjectType/ObjectType_interfaceDeclaration.js";
 import { ObjectType_isTypeFunctionDeclaration } from "./_ObjectType/ObjectType_isTypeFunctionDeclaration.js";
-import { ObjectType_jsonFunctionDeclarations } from "./_ObjectType/ObjectType_jsonFunctionDeclarations.js";
+import { ObjectType_jsonSchemaFunctionDeclaration } from "./_ObjectType/ObjectType_jsonSchemaFunctionDeclaration.js";
 import { ObjectType_jsonTypeAliasDeclaration } from "./_ObjectType/ObjectType_jsonTypeAliasDeclaration.js";
+import { ObjectType_jsonUiSchemaFunctionDeclaration } from "./_ObjectType/ObjectType_jsonUiSchemaFunctionDeclaration.js";
+import { ObjectType_jsonZodSchemaFunctionDeclaration } from "./_ObjectType/ObjectType_jsonZodSchemaFunctionDeclaration.js";
 import { ObjectType_objectSetMethodNames } from "./_ObjectType/ObjectType_objectSetMethodNames.js";
-import { ObjectType_rdfFunctionDeclarations } from "./_ObjectType/ObjectType_rdfFunctionDeclarations.js";
+import { ObjectType_propertiesFromRdfFunctionDeclaration } from "./_ObjectType/ObjectType_propertiesFromRdfFunctionDeclaration.js";
 import { ObjectType_schemaVariableStatement } from "./_ObjectType/ObjectType_schemaVariableStatement.js";
-import { ObjectType_sparqlFunctionDeclarations } from "./_ObjectType/ObjectType_sparqlFunctionDeclarations.js";
+import { ObjectType_sparqlConstructQueryFunctionDeclaration } from "./_ObjectType/ObjectType_sparqlConstructQueryFunctionDeclaration.js";
+import { ObjectType_sparqlConstructQueryStringFunctionDeclaration } from "./_ObjectType/ObjectType_sparqlConstructQueryStringFunctionDeclaration.js";
+import { ObjectType_sparqlConstructTriplesFunctionDeclaration } from "./_ObjectType/ObjectType_sparqlConstructTriplesFunctionDeclaration.js";
+import { ObjectType_sparqlWherePatternsFunctionDeclaration } from "./_ObjectType/ObjectType_sparqlWherePatternsFunctionDeclarations.js";
+import { ObjectType_toJsonFunctionOrMethodDeclaration } from "./_ObjectType/ObjectType_toJsonFunctionOrMethodDeclaration.js";
+import { ObjectType_toRdfFunctionOrMethodDeclaration } from "./_ObjectType/ObjectType_toRdfFunctionOrMethodDeclaration.js";
 import { ShaclProperty as _ShaclProperty } from "./_ObjectType/ShaclProperty.js";
 import { TypeDiscriminantProperty as _TypeDiscriminantProperty } from "./_ObjectType/TypeDiscriminantProperty.js";
 import { AbstractDeclaredType } from "./AbstractDeclaredType.js";
@@ -108,7 +117,11 @@ export class ObjectType extends AbstractDeclaredType {
                     break;
                 }
             }
-            staticModuleDeclarations.push(ObjectType_filterFunctionDeclaration.bind(this)(), ObjectType_filterTypeDeclaration.bind(this)(), ...ObjectType_fromRdfTypeVariableStatement.bind(this)().toList(), ...ObjectType_graphqlTypeVariableStatement.bind(this)().toList(), ...identifierTypeDeclarations.bind(this)(), ...ObjectType_jsonFunctionDeclarations.bind(this)(), ...ObjectType_jsonTypeAliasDeclaration.bind(this)().toList(), ObjectType_isTypeFunctionDeclaration.bind(this)(), ...ObjectType_rdfFunctionDeclarations.bind(this)(), ObjectType_schemaVariableStatement.bind(this)(), ...ObjectType_sparqlFunctionDeclarations.bind(this)());
+            staticModuleDeclarations.push(...ObjectType_graphqlTypeVariableStatement.bind(this)().toList(), ...identifierTypeDeclarations.bind(this)(), ...ObjectType_jsonTypeAliasDeclaration.bind(this)().toList(), ObjectType_filterFunctionDeclaration.bind(this)(), ObjectType_filterTypeDeclaration.bind(this)(), ...ObjectType_fromJsonFunctionDeclarations.bind(this)(), ...ObjectType_fromRdfFunctionDeclaration.bind(this)().toList(), ...ObjectType_fromRdfTypeVariableStatement.bind(this)().toList(), ObjectType_isTypeFunctionDeclaration.bind(this)(), ...ObjectType_jsonSchemaFunctionDeclaration.bind(this)().toList(), ...ObjectType_jsonUiSchemaFunctionDeclaration.bind(this)().toList(), ...ObjectType_jsonZodSchemaFunctionDeclaration.bind(this)().toList(), ...ObjectType_propertiesFromRdfFunctionDeclaration.bind(this)().toList(), ObjectType_schemaVariableStatement.bind(this)(), ...ObjectType_sparqlConstructQueryFunctionDeclaration.bind(this)().toList(), ...ObjectType_sparqlConstructQueryStringFunctionDeclaration.bind(this)().toList(), ...ObjectType_sparqlConstructTriplesFunctionDeclaration.bind(this)().toList(), ...ObjectType_sparqlWherePatternsFunctionDeclaration.bind(this)().toList(), ...(this.declarationType === "interface"
+                ? ObjectType_toJsonFunctionOrMethodDeclaration.bind(this)().toList()
+                : []), ...(this.declarationType === "interface"
+                ? ObjectType_toRdfFunctionOrMethodDeclaration.bind(this)().toList()
+                : []));
             if (staticModuleDeclarations.length > 0) {
                 declarations.push(code `\
 export namespace ${def(this.staticModuleName)} {
@@ -201,10 +214,10 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
         return code `typeof ${this.schema}`;
     }
     get sparqlConstructTriplesFunction() {
-        return code `(({ filter, ignoreRdfType, valueVariable, variablePrefix }: ${snippets.SparqlConstructTriplesFunctionParameters}<${this.filterType}, ${this.schemaType}>) => ${this.staticModuleName}.${syntheticNamePrefix}sparqlConstructTriples({ filter, focusIdentifier: valueVariable, ignoreRdfType: ignoreRdfType ?? true, variablePrefix }))`;
+        return code `(({ filter, ignoreRdfType, valueVariable, variablePrefix }: ${snippets.SparqlConstructTriplesFunctionParameters}<${this.filterType}, ${this.schemaType}>) => ${this.staticModuleName}.${syntheticNamePrefix}sparqlConstructTriples({ filter, focusIdentifier: valueVariable, ignoreRdfType, variablePrefix }))`;
     }
     get sparqlWherePatternsFunction() {
-        return code `(({ filter, ignoreRdfType, propertyPatterns, valueVariable, variablePrefix }: ${snippets.SparqlWherePatternsFunctionParameters}<${this.filterType}, ${this.schemaType}>) => (propertyPatterns as readonly ${snippets.SparqlPattern}[]).concat(${this.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns({ filter, focusIdentifier: valueVariable, ignoreRdfType: ignoreRdfType ?? true, variablePrefix })))`;
+        return code `(({ filter, ignoreRdfType, preferredLanguages, propertyPatterns, valueVariable, variablePrefix }: ${snippets.SparqlWherePatternsFunctionParameters}<${this.filterType}, ${this.schemaType}>) => (propertyPatterns as readonly ${snippets.SparqlPattern}[]).concat(${this.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns({ filter, focusIdentifier: valueVariable, ignoreRdfType, preferredLanguages, variablePrefix })))`;
     }
     get toRdfjsResourceType() {
         if (this.parentObjectTypes.length > 0) {

package/dist/generators/ts/ObjectUnionType.js

@@ -9,19 +9,25 @@ import { Maybe, NonEmptyList } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { ObjectType_objectSetMethodNames } from "./_ObjectType/ObjectType_objectSetMethodNames.js";
+import { ObjectType_sparqlConstructQueryFunctionDeclaration } from "./_ObjectType/ObjectType_sparqlConstructQueryFunctionDeclaration.js";
+import { ObjectType_sparqlConstructQueryStringFunctionDeclaration } from "./_ObjectType/ObjectType_sparqlConstructQueryStringFunctionDeclaration.js";
 import { MemberType } from "./_ObjectUnionType/MemberType.js";
 import { ObjectUnionType_equalsFunctionDeclaration } from "./_ObjectUnionType/ObjectUnionType_equalsFunctionDeclaration.js";
 import { ObjectUnionType_filterFunctionDeclaration } from "./_ObjectUnionType/ObjectUnionType_filterFunctionDeclaration.js";
 import { ObjectUnionType_filterTypeDeclaration } from "./_ObjectUnionType/ObjectUnionType_filterTypeDeclaration.js";
+import { ObjectUnionType_fromJsonFunctionDeclaration } from "./_ObjectUnionType/ObjectUnionType_fromJsonFunctionDeclaration.js";
+import { ObjectUnionType_fromRdfFunctionDeclaration } from "./_ObjectUnionType/ObjectUnionType_fromRdfFunctionDeclarations.js";
 import { ObjectUnionType_graphqlTypeVariableStatement } from "./_ObjectUnionType/ObjectUnionType_graphqlTypeVariableStatement.js";
 import { ObjectUnionType_hashFunctionDeclaration } from "./_ObjectUnionType/ObjectUnionType_hashFunctionDeclaration.js";
 import { ObjectUnionType_identifierTypeDeclarations } from "./_ObjectUnionType/ObjectUnionType_identifierTypeDeclarations.js";
 import { ObjectUnionType_isTypeFunctionDeclaration } from "./_ObjectUnionType/ObjectUnionType_isTypeFunctionDeclaration.js";
-import { jsonFunctionDeclarations } from "./_ObjectUnionType/ObjectUnionType_jsonFunctionDeclarations.js";
 import { ObjectUnionType_jsonTypeAliasDeclaration } from "./_ObjectUnionType/ObjectUnionType_jsonTypeAliasDeclaration.js";
-import { rdfFunctionDeclarations } from "./_ObjectUnionType/ObjectUnionType_rdfFunctionDeclarations.js";
+import { ObjectUnionType_jsonZodSchemaFunctionDeclaration } from "./_ObjectUnionType/ObjectUnionType_jsonZodSchemaFunctionDeclaration.js";
 import { ObjectUnionType_schemaVariableStatement } from "./_ObjectUnionType/ObjectUnionType_schemaVariableStatement.js";
-import { ObjectUnionType_sparqlFunctionDeclarations } from "./_ObjectUnionType/ObjectUnionType_sparqlFunctionDeclarations.js";
+import { ObjectUnionType_sparqlConstructTriplesFunctionDeclaration } from "./_ObjectUnionType/ObjectUnionType_sparqlConstructTriplesFunctionDeclaration.js";
+import { ObjectUnionType_sparqlWherePatternsFunctionDeclaration } from "./_ObjectUnionType/ObjectUnionType_sparqlWherePatternsFunctionDeclaration.js";
+import { ObjectUnionType_toJsonFunctionDeclaration } from "./_ObjectUnionType/ObjectUnionType_toJsonFunctionDeclaration.js";
+import { ObjectUnionType_toRdfFunctionDeclaration } from "./_ObjectUnionType/ObjectUnionType_toRdfFunctionDeclarations.js";
 import { ObjectUnionType_typeAliasDeclaration } from "./_ObjectUnionType/ObjectUnionType_typeAliasDeclaration.js";
 import { AbstractDeclaredType } from "./AbstractDeclaredType.js";
 import { imports } from "./imports.js";
@@ -68,18 +74,24 @@ export class ObjectUnionType extends AbstractDeclaredType {
             ObjectUnionType_typeAliasDeclaration.bind(this)(),
         ];
         const staticModuleDeclarations = [
+            ...ObjectUnionType_graphqlTypeVariableStatement.bind(this)().toList(),
+            ...ObjectUnionType_identifierTypeDeclarations.bind(this)(),
+            ...ObjectUnionType_jsonTypeAliasDeclaration.bind(this)().toList(),
             ...ObjectUnionType_equalsFunctionDeclaration.bind(this)().toList(),
             ObjectUnionType_filterFunctionDeclaration.bind(this)(),
             ObjectUnionType_filterTypeDeclaration.bind(this)(),
-            ...ObjectUnionType_graphqlTypeVariableStatement.bind(this)().toList(),
             ...ObjectUnionType_hashFunctionDeclaration.bind(this)().toList(),
-            ...ObjectUnionType_identifierTypeDeclarations.bind(this)(),
-            ...jsonFunctionDeclarations.bind(this)(),
-            ...ObjectUnionType_jsonTypeAliasDeclaration.bind(this)().toList(),
+            ...ObjectUnionType_fromJsonFunctionDeclaration.bind(this)().toList(),
+            ...ObjectUnionType_fromRdfFunctionDeclaration.bind(this)().toList(),
             ...ObjectUnionType_isTypeFunctionDeclaration.bind(this)().toList(),
+            ...ObjectUnionType_jsonZodSchemaFunctionDeclaration.bind(this)().toList(),
             ObjectUnionType_schemaVariableStatement.bind(this)(),
-            ...rdfFunctionDeclarations.bind(this)(),
-            ...ObjectUnionType_sparqlFunctionDeclarations.bind(this)(),
+            ...ObjectType_sparqlConstructQueryFunctionDeclaration.bind(this)().toList(),
+            ...ObjectType_sparqlConstructQueryStringFunctionDeclaration.bind(this)().toList(),
+            ...ObjectUnionType_sparqlConstructTriplesFunctionDeclaration.bind(this)().toList(),
+            ...ObjectUnionType_sparqlWherePatternsFunctionDeclaration.bind(this)().toList(),
+            ...ObjectUnionType_toJsonFunctionDeclaration.bind(this)().toList(),
+            ...ObjectUnionType_toRdfFunctionDeclaration.bind(this)().toList(),
         ];
         if (staticModuleDeclarations.length > 0) {
             declarations.push(code `\
@@ -120,10 +132,10 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
         return code `typeof ${this.schema}`;
     }
     get sparqlConstructTriplesFunction() {
-        return code `(({ ignoreRdfType, schema, ...otherParameters }: ${snippets.SparqlConstructTriplesFunctionParameters}<${this.filterType}, ${this.schemaType}>) => ${this.staticModuleName}.${syntheticNamePrefix}sparqlConstructTriples(otherParameters))`;
+        return code `(({ ignoreRdfType, schema, valueVariable, ...otherParameters }: ${snippets.SparqlConstructTriplesFunctionParameters}<${this.filterType}, ${this.schemaType}>) => ${this.staticModuleName}.${syntheticNamePrefix}sparqlConstructTriples({ ...otherParameters, focusIdentifier: valueVariable, ignoreRdfType: false }))`;
     }
     get sparqlWherePatternsFunction() {
-        return code `(({ ignoreRdfType, propertyPatterns, schema, valueVariable, ...otherParameters }: ${snippets.SparqlWherePatternsFunctionParameters}<${this.filterType}, ${this.schemaType}>) => (propertyPatterns as readonly ${snippets.SparqlPattern}[]).concat(${this.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns({ focusIdentifier: valueVariable, ...otherParameters })))`;
+        return code `(({ ignoreRdfType, propertyPatterns, schema, valueVariable, ...otherParameters }: ${snippets.SparqlWherePatternsFunctionParameters}<${this.filterType}, ${this.schemaType}>) => (propertyPatterns as readonly ${snippets.SparqlPattern}[]).concat(${this.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns({  ...otherParameters, focusIdentifier: valueVariable, ignoreRdfType: false })))`;
     }
     get staticModuleName() {
         return this.name;

package/dist/generators/ts/ZodGenerator.d.ts

@@ -0,0 +1,7 @@
+import * as ast from "../../ast/index.js";
+import type { Generator } from "../Generator.js";
+export declare class ZodGenerator implements Generator {
+    private readonly typeFactory;
+    generate(ast_: ast.Ast): string;
+}
+//# sourceMappingURL=ZodGenerator.d.ts.map

package/dist/generators/ts/ZodGenerator.js

@@ -0,0 +1,37 @@
+import * as ast from "../../ast/index.js";
+import { ObjectType_jsonTypeAliasDeclaration } from "./_ObjectType/ObjectType_jsonTypeAliasDeclaration.js";
+import { ObjectType_jsonZodSchemaFunctionDeclaration } from "./_ObjectType/ObjectType_jsonZodSchemaFunctionDeclaration.js";
+import { ObjectUnionType_jsonTypeAliasDeclaration } from "./_ObjectUnionType/ObjectUnionType_jsonTypeAliasDeclaration.js";
+import { ObjectUnionType_jsonZodSchemaFunctionDeclaration } from "./_ObjectUnionType/ObjectUnionType_jsonZodSchemaFunctionDeclaration.js";
+import { snippets } from "./snippets.js";
+import { TypeFactory } from "./TypeFactory.js";
+import { code, joinCode } from "./ts-poet-wrapper.js";
+export class ZodGenerator {
+    typeFactory = new TypeFactory();
+    generate(ast_) {
+        const declarations = [];
+        for (const objectType of ast.ObjectType.toposort(ast_.objectTypes).map((astObjectType) => this.typeFactory.createObjectType(astObjectType))) {
+            declarations.push(code `\
+export namespace ${objectType.staticModuleName} {
+${joinCode([
+                ...ObjectType_jsonTypeAliasDeclaration.bind(objectType)().toList(),
+                ...ObjectType_jsonZodSchemaFunctionDeclaration.bind(objectType)().toList(),
+            ], { on: "\n\n" })}
+}`);
+        }
+        for (const objectUnionType of ast_.objectUnionTypes.map((astObjectUnionType) => this.typeFactory.createObjectUnionType(astObjectUnionType))) {
+            declarations.push(code `\
+export namespace ${objectUnionType.staticModuleName} {
+${joinCode([
+                ...ObjectUnionType_jsonTypeAliasDeclaration.bind(objectUnionType)().toList(),
+                ...ObjectUnionType_jsonZodSchemaFunctionDeclaration.bind(objectUnionType)().toList(),
+            ], { on: "\n\n" })}
+}`);
+        }
+        declarations.splice(0, 0, joinCode(Object.values(snippets)
+            .sort((left, right) => left.usageSiteName.localeCompare(right.usageSiteName))
+            .map((snippet) => code `${snippet.ifUsed}`), { on: "\n\n" }));
+        return joinCode(declarations, { on: "\n\n" }).toString({});
+    }
+}
+//# sourceMappingURL=ZodGenerator.js.map

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

@@ -300,6 +300,7 @@ export class IdentifierProperty extends AbstractProperty {
             condition: code `${variables.focusIdentifier}.termType === "Variable"`,
             patterns: code `${this.type.sparqlWherePatternsFunction}(${{
                 filter: code `${variables.filter}?.${this.name}`,
+                ignoreRdfType: true, // Unused
                 preferredLanguages: variables.preferredLanguages,
                 propertyPatterns: code `[]`,
                 schema: code `${this.objectType.staticModuleName}.${syntheticNamePrefix}schema.properties.${this.objectType.identifierProperty.name}.type()`,

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

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

package/dist/generators/ts/_ObjectType/{ObjectType_jsonFunctionDeclarations.js → ObjectType_fromJsonFunctionDeclarations.js}

@@ -1,10 +1,14 @@
-import { Maybe } from "purify-ts";
 import { imports } from "../imports.js";
 import { snippets } from "../snippets.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-import { ObjectType_toJsonFunctionOrMethodDeclaration } from "./ObjectType_toJsonFunctionOrMethodDeclaration.js";
-function ObjectType_fromJsonFunctionDeclarations() {
+const variables = {
+    jsonObject: code `${syntheticNamePrefix}jsonObject`,
+};
+export function ObjectType_fromJsonFunctionDeclarations() {
+    if (!this.features.has("json")) {
+        return [];
+    }
     const initializers = [];
     const propertiesFromJsonReturnType = [];
     const propertiesFromJsonStatements = [];
@@ -59,64 +63,4 @@ export function ${syntheticNamePrefix}fromJson(json: unknown): ${imports.Either}
 }`);
     return functionDeclarations;
 }
-function ObjectType_jsonSchemaFunctionDeclaration() {
-    return code `\
-export function ${syntheticNamePrefix}jsonSchema() {
-  return ${imports.z}.toJSONSchema(${syntheticNamePrefix}jsonZodSchema());
-}`;
-}
-function ObjectType_jsonUiSchemaFunctionDeclaration() {
-    const variables = { scopePrefix: code `scopePrefix` };
-    const elements = this.parentObjectTypes
-        .map((parentObjectType) => code `${parentObjectType.staticModuleName}.${syntheticNamePrefix}jsonUiSchema({ scopePrefix })`)
-        .concat(this.ownProperties.flatMap((property) => property.jsonUiSchemaElement({ variables }).toList()));
-    return code `\
-export function ${syntheticNamePrefix}jsonUiSchema(parameters?: { scopePrefix?: string }): any {
-  const scopePrefix = parameters?.scopePrefix ?? "#";
-  return { "elements": [ ${joinCode(elements, { on: "," })} ], label: "${this.label.orDefault(this.name)}", type: "Group" };
-}`;
-}
-function ObjectType_jsonZodSchemaFunctionDeclaration() {
-    const mergeZodObjectSchemas = [];
-    for (const parentObjectType of this.parentObjectTypes) {
-        mergeZodObjectSchemas.push(parentObjectType.jsonZodSchema({ context: "type" }));
-    }
-    if (this.properties.length > 0) {
-        mergeZodObjectSchemas.push(code `${imports.z}.object({ ${joinCode(this.properties
-            .flatMap((property) => property.jsonZodSchema.toList())
-            .map(({ key, schema }) => code `"${key}": ${schema}`), { on: "," })} })`);
-    }
-    return code `\
-export function ${syntheticNamePrefix}jsonZodSchema() {
-  return ${mergeZodObjectSchemas.length > 0
-        ? mergeZodObjectSchemas.reduce((merged, zodObjectSchema) => {
-            if (merged === null) {
-                return zodObjectSchema;
-            }
-            return code `${merged}.merge(${zodObjectSchema})`;
-        }, null)
-        : `${imports.z}.object()`} satisfies ${imports.z}.ZodType<${syntheticNamePrefix}Json>;
-}`;
-}
-function ObjectType_toJsonFunctionDeclaration() {
-    if (this.declarationType !== "interface") {
-        return Maybe.empty();
-    }
-    return ObjectType_toJsonFunctionOrMethodDeclaration.bind(this)();
-}
-export function ObjectType_jsonFunctionDeclarations() {
-    if (!this.features.has("json")) {
-        return [];
-    }
-    return [
-        ...ObjectType_fromJsonFunctionDeclarations.bind(this)(),
-        ObjectType_jsonSchemaFunctionDeclaration.bind(this)(),
-        ObjectType_jsonUiSchemaFunctionDeclaration.bind(this)(),
-        ...ObjectType_toJsonFunctionDeclaration.bind(this)().toList(),
-        ObjectType_jsonZodSchemaFunctionDeclaration.bind(this)(),
-    ];
-}
-const variables = {
-    jsonObject: code `${syntheticNamePrefix}jsonObject`,
-};
-//# sourceMappingURL=ObjectType_jsonFunctionDeclarations.js.map
+//# sourceMappingURL=ObjectType_fromJsonFunctionDeclarations.js.map

package/dist/generators/ts/_ObjectType/ObjectType_fromRdfFunctionDeclaration.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_fromRdfFunctionDeclaration(this: ObjectType): Maybe<Code>;
+//# sourceMappingURL=ObjectType_fromRdfFunctionDeclaration.d.ts.map

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

@@ -0,0 +1,27 @@
+import { Maybe } from "purify-ts";
+import { imports } from "../imports.js";
+import { snippets } from "../snippets.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectType_fromRdfFunctionDeclaration() {
+    if (!this.features.has("rdf")) {
+        return Maybe.empty();
+    }
+    if (this.abstract) {
+        return Maybe.empty();
+    }
+    const statements = [
+        code `let { context, ignoreRdfType = false, objectSet, preferredLanguages } = (options ?? {});`,
+        code `if (!objectSet) { objectSet = new ${syntheticNamePrefix}RdfjsDatasetObjectSet(resource.dataset); }`,
+    ];
+    let propertiesFromRdfExpression = code `${this.staticModuleName}.${syntheticNamePrefix}propertiesFromRdf({ context, ignoreRdfType, objectSet, preferredLanguages, resource })`;
+    if (this.declarationType === "class") {
+        propertiesFromRdfExpression = code `${propertiesFromRdfExpression}.map(properties => new ${this.name}(properties))`;
+    }
+    statements.push(code `return ${propertiesFromRdfExpression};`);
+    return Maybe.of(code `\
+export function ${syntheticNamePrefix}fromRdf(resource: ${imports.Resource}, options?: ${snippets.FromRdfOptions}): ${imports.Either}<Error, ${this.name}> {
+${joinCode(statements)}
+}`);
+}
+//# sourceMappingURL=ObjectType_fromRdfFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_jsonSchemaFunctionDeclaration.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_jsonSchemaFunctionDeclaration(this: ObjectType): Maybe<Code>;
+//# sourceMappingURL=ObjectType_jsonSchemaFunctionDeclaration.d.ts.map

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

@@ -0,0 +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_jsonSchemaFunctionDeclaration() {
+    if (!this.features.has("json")) {
+        return Maybe.empty();
+    }
+    return Maybe.of(code `\
+export function ${syntheticNamePrefix}jsonSchema() {
+  return ${imports.z}.toJSONSchema(${syntheticNamePrefix}jsonZodSchema());
+}`);
+}
+//# sourceMappingURL=ObjectType_jsonSchemaFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_jsonUiSchemaFunctionDeclaration.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_jsonUiSchemaFunctionDeclaration(this: ObjectType): Maybe<Code>;
+//# sourceMappingURL=ObjectType_jsonUiSchemaFunctionDeclaration.d.ts.map

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

@@ -0,0 +1,18 @@
+import { Maybe } from "purify-ts";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectType_jsonUiSchemaFunctionDeclaration() {
+    if (!this.features.has("json")) {
+        return Maybe.empty();
+    }
+    const variables = { scopePrefix: code `scopePrefix` };
+    const elements = this.parentObjectTypes
+        .map((parentObjectType) => code `${parentObjectType.staticModuleName}.${syntheticNamePrefix}jsonUiSchema({ scopePrefix })`)
+        .concat(this.ownProperties.flatMap((property) => property.jsonUiSchemaElement({ variables }).toList()));
+    return Maybe.of(code `\
+export function ${syntheticNamePrefix}jsonUiSchema(parameters?: { scopePrefix?: string }): any {
+  const scopePrefix = parameters?.scopePrefix ?? "#";
+  return { "elements": [ ${joinCode(elements, { on: "," })} ], label: "${this.label.orDefault(this.name)}", type: "Group" };
+}`);
+}
+//# sourceMappingURL=ObjectType_jsonUiSchemaFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_jsonZodSchemaFunctionDeclaration.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_jsonZodSchemaFunctionDeclaration(this: ObjectType): Maybe<Code>;
+//# sourceMappingURL=ObjectType_jsonZodSchemaFunctionDeclaration.d.ts.map

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

@@ -0,0 +1,30 @@
+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 ObjectType_jsonZodSchemaFunctionDeclaration() {
+    if (!this.features.has("json")) {
+        return Maybe.empty();
+    }
+    const mergeZodObjectSchemas = [];
+    for (const parentObjectType of this.parentObjectTypes) {
+        mergeZodObjectSchemas.push(parentObjectType.jsonZodSchema({ context: "type" }));
+    }
+    if (this.properties.length > 0) {
+        mergeZodObjectSchemas.push(code `${imports.z}.object({ ${joinCode(this.properties
+            .flatMap((property) => property.jsonZodSchema.toList())
+            .map(({ key, schema }) => code `"${key}": ${schema}`), { on: "," })} })`);
+    }
+    return Maybe.of(code `\
+export function ${syntheticNamePrefix}jsonZodSchema() {
+  return ${mergeZodObjectSchemas.length > 0
+        ? mergeZodObjectSchemas.reduce((merged, zodObjectSchema) => {
+            if (merged === null) {
+                return zodObjectSchema;
+            }
+            return code `${merged}.merge(${zodObjectSchema})`;
+        }, null)
+        : `${imports.z}.object()`} satisfies ${imports.z}.ZodType<${syntheticNamePrefix}Json>;
+}`);
+}
+//# sourceMappingURL=ObjectType_jsonZodSchemaFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_propertiesFromRdfFunctionDeclaration.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_propertiesFromRdfFunctionDeclaration(this: ObjectType): Maybe<Code>;
+//# sourceMappingURL=ObjectType_propertiesFromRdfFunctionDeclaration.d.ts.map

package/dist/generators/ts/_ObjectType/{ObjectType_rdfFunctionDeclarations.js → ObjectType_propertiesFromRdfFunctionDeclaration.js}

@@ -5,26 +5,10 @@ import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
 import { snippets } from "../snippets.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-import { ObjectType_toRdfFunctionOrMethodDeclaration } from "./ObjectType_toRdfFunctionOrMethodDeclaration.js";
-function ObjectType_fromRdfFunctionDeclaration() {
-    if (this.abstract) {
+export function ObjectType_propertiesFromRdfFunctionDeclaration() {
+    if (!this.features.has("rdf")) {
         return Maybe.empty();
     }
-    const statements = [
-        code `let { context, ignoreRdfType = false, objectSet, preferredLanguages } = (options ?? {});`,
-        code `if (!objectSet) { objectSet = new ${syntheticNamePrefix}RdfjsDatasetObjectSet(resource.dataset); }`,
-    ];
-    let propertiesFromRdfExpression = code `${this.staticModuleName}.${syntheticNamePrefix}propertiesFromRdf({ context, ignoreRdfType, objectSet, preferredLanguages, resource })`;
-    if (this.declarationType === "class") {
-        propertiesFromRdfExpression = code `${propertiesFromRdfExpression}.map(properties => new ${this.name}(properties))`;
-    }
-    statements.push(code `return ${propertiesFromRdfExpression};`);
-    return Maybe.of(code `\
-export function ${syntheticNamePrefix}fromRdf(resource: ${imports.Resource}, options?: ${snippets.FromRdfOptions}): ${imports.Either}<Error, ${this.name}> {
-${joinCode(statements)}
-}`);
-}
-function ObjectType_propertiesFromRdfFunctionDeclaration() {
     const chains = [];
     const initializers = [];
     const propertySignatures = [];
@@ -108,25 +92,9 @@ function ObjectType_propertiesFromRdfFunctionDeclaration() {
     if (propertySignatures.length > 0) {
         returnType.splice(0, 0, code `{ ${joinCode(propertySignatures, { on: " " })} }`);
     }
-    return code `\
+    return Maybe.of(code `\
 export function ${syntheticNamePrefix}propertiesFromRdf(${syntheticNamePrefix}parameters: ${snippets.PropertiesFromRdfParameters}): ${imports.Either}<Error, ${joinCode(returnType, { on: " & " })}> {
 ${joinCode(statements)}
-}`;
-}
-export function ObjectType_rdfFunctionDeclarations() {
-    if (!this.features.has("rdf")) {
-        return [];
-    }
-    return [
-        ...ObjectType_fromRdfFunctionDeclaration.bind(this)().toList(),
-        ObjectType_propertiesFromRdfFunctionDeclaration.bind(this)(),
-        ...ObjectType_toRdfFunctionDeclaration.bind(this)().toList(),
-    ];
-}
-function ObjectType_toRdfFunctionDeclaration() {
-    if (this.declarationType !== "interface") {
-        return Maybe.empty();
-    }
-    return ObjectType_toRdfFunctionOrMethodDeclaration.bind(this)();
+}`);
 }
-//# sourceMappingURL=ObjectType_rdfFunctionDeclarations.js.map
+//# sourceMappingURL=ObjectType_propertiesFromRdfFunctionDeclaration.js.map

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

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

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

@@ -1,12 +1,42 @@
+import { camelCase } 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 } from "../ts-poet-wrapper.js";
 export function ObjectType_sparqlConstructQueryFunctionDeclaration() {
-    return code `\
-export function ${syntheticNamePrefix}sparqlConstructQuery(parameters?: { filter?: ${this.filterType}; ignoreRdfType?: boolean; prefixes?: { [prefix: string]: string }; preferredLanguages?: readonly string[]; subject?: ${imports.NamedNode} | ${imports.Variable} } & Omit<${imports.sparqljs}.ConstructQuery, "prefixes" | "queryType" | "type">): ${imports.sparqljs}.ConstructQuery {
-  const { filter, ignoreRdfType, preferredLanguages, subject, ...queryParameters } = parameters ?? {};
-  return { ...queryParameters, prefixes: parameters?.prefixes ?? {}, queryType: "CONSTRUCT", template: (queryParameters.template ?? []).concat(${this.staticModuleName}.${syntheticNamePrefix}sparqlConstructTriples({ filter, focusIdentifier: subject, ignoreRdfType })), type: "query", where: (queryParameters.where ?? []).concat(${snippets.normalizeSparqlWherePatterns}(${this.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns({ filter, focusIdentifier: subject, ignoreRdfType, preferredLanguages }))) };
-}`;
+    if (!this.features.has("sparql")) {
+        return Maybe.empty();
+    }
+    return Maybe.of(code `\
+export function ${syntheticNamePrefix}sparqlConstructQuery({ filter, ignoreRdfType, preferredLanguages, prefixes, subject, ...queryParameters }: { filter?: ${this.filterType}; ignoreRdfType?: boolean; prefixes?: { [prefix: string]: string }; preferredLanguages?: readonly string[]; subject: ${imports.NamedNode} | ${imports.Variable} } & Omit<${imports.sparqljs}.ConstructQuery, "prefixes" | "queryType" | "type">): ${imports.sparqljs}.ConstructQuery {
+  const variablePrefix = subject.termType === "Variable" ? subject.value : "${camelCase(this.name)}";
+
+  return {
+    ...queryParameters,
+    prefixes: prefixes ?? {},
+    queryType: "CONSTRUCT",
+    template: (queryParameters.template ?? []).concat(
+      ${this.staticModuleName}.${syntheticNamePrefix}sparqlConstructTriples({
+        filter,
+        focusIdentifier: subject,
+        ignoreRdfType: !!ignoreRdfType,
+        variablePrefix
+      })
+    ),
+    type: "query",
+    where: (queryParameters.where ?? []).concat(
+      ${snippets.normalizeSparqlWherePatterns}(
+        ${this.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns({
+          filter,
+          focusIdentifier: subject,
+          ignoreRdfType: !!ignoreRdfType,
+          preferredLanguages,
+          variablePrefix
+        })
+      )
+    )
+  };
+}`);
 }
 //# sourceMappingURL=ObjectType_sparqlConstructQueryFunctionDeclaration.js.map