@shaclmate/compiler 4.0.9 → 4.0.10

package/dist/generators/ts/ListType.js

@@ -135,7 +135,7 @@ __decorate([
             case "LiteralType":
             case "NamedObjectUnionType":
             case "NamedUnionType":
-            case "ObjectType":
+            case "NamedObjectType":
             case "StringType":
             case "TermType":
                 return true;

package/dist/generators/ts/LiteralType.d.ts

@@ -12,7 +12,7 @@ export declare class LiteralType extends AbstractLiteralType {
     graphqlResolveExpression(_parameters: Parameters<AbstractLiteralType["graphqlResolveExpression"]>[0]): Code;
     hashStatements({ depth, variables, }: Parameters<AbstractLiteralType["hashStatements"]>[0]): readonly Code[];
     jsonType(parameters?: Parameters<AbstractLiteralType["jsonType"]>[0]): AbstractLiteralType.JsonType;
-    jsonZodSchema({ includeDiscriminantProperty, }: Parameters<AbstractLiteralType["jsonZodSchema"]>[0]): Code;
+    jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractLiteralType["jsonSchema"]>[0]): Code;
     toJsonExpression({ includeDiscriminantProperty, variables, }: Parameters<AbstractLiteralType["toJsonExpression"]>[0]): Code;
 }
 //# sourceMappingURL=LiteralType.d.ts.map

package/dist/generators/ts/LiteralType.js

@@ -32,7 +32,7 @@ export class LiteralType extends AbstractLiteralType {
             : "";
         return new AbstractLiteralType.JsonType(code `{ readonly "@language"?: string${discriminantProperty}, readonly "@type"?: string, readonly "@value": string }`);
     }
-    jsonZodSchema({ includeDiscriminantProperty, }) {
+    jsonSchema({ includeDiscriminantProperty, }) {
         const discriminantProperty = includeDiscriminantProperty
             ? code `, termType: ${imports.z}.literal("Literal")`
             : "";

package/dist/generators/ts/{ObjectType.d.ts → NamedObjectType.d.ts}

@@ -2,18 +2,18 @@ import type { NamedNode } from "@rdfjs/types";
 import { Maybe, NonEmptyList } from "purify-ts";
 import type { TsFeature } from "../../enums/TsFeature.js";
 import type { TsObjectDeclarationType } from "../../enums/TsObjectDeclarationType.js";
-import { DiscriminantProperty as _DiscriminantProperty } from "./_ObjectType/DiscriminantProperty.js";
-import { IdentifierPrefixProperty as _IdentifierPrefixProperty } from "./_ObjectType/IdentifierPrefixProperty.js";
-import { IdentifierProperty as _IdentifierProperty } from "./_ObjectType/IdentifierProperty.js";
-import type { Property as _Property } from "./_ObjectType/Property.js";
-import { ShaclProperty as _ShaclProperty } from "./_ObjectType/ShaclProperty.js";
+import { DiscriminantProperty as _DiscriminantProperty } from "./_NamedObjectType/DiscriminantProperty.js";
+import { IdentifierPrefixProperty as _IdentifierPrefixProperty } from "./_NamedObjectType/IdentifierPrefixProperty.js";
+import { IdentifierProperty as _IdentifierProperty } from "./_NamedObjectType/IdentifierProperty.js";
+import type { Property as _Property } from "./_NamedObjectType/Property.js";
+import { ShaclProperty as _ShaclProperty } from "./_NamedObjectType/ShaclProperty.js";
 import { AbstractType } from "./AbstractType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
 import type { IdentifierType } from "./IdentifierType.js";
 import type { IriType } from "./IriType.js";
 import type { Type } from "./Type.js";
 import { type Code } from "./ts-poet-wrapper.js";
-export declare class ObjectType extends AbstractType {
+export declare class NamedObjectType extends AbstractType {
     private readonly imports;
     protected readonly toRdfTypes: readonly NamedNode[];
     readonly abstract: boolean;
@@ -23,7 +23,7 @@ export declare class ObjectType extends AbstractType {
     readonly fromRdfType: Maybe<NamedNode>;
     readonly graphqlArgs: AbstractType["graphqlArgs"];
     readonly identifierType: BlankNodeType | IdentifierType | IriType;
-    readonly kind = "ObjectType";
+    readonly kind = "NamedObjectType";
     readonly name: string;
     readonly recursive: boolean;
     readonly staticModuleName: string;
@@ -39,26 +39,27 @@ export declare class ObjectType extends AbstractType {
         identifierType: BlankNodeType | IdentifierType | IriType;
         imports: readonly string[];
         label: Maybe<string>;
-        lazyAncestorObjectTypes: () => readonly ObjectType[];
-        lazyChildObjectTypes: () => readonly ObjectType[];
-        lazyDiscriminantProperty: (objectType: ObjectType) => ObjectType.DiscriminantProperty;
-        lazyIdentifierProperty: (objectType: ObjectType) => ObjectType.IdentifierProperty;
-        lazyDescendantObjectTypes: () => readonly ObjectType[];
-        lazyParentObjectTypes: () => readonly ObjectType[];
-        lazyProperties: (objectType: ObjectType) => readonly ObjectType.Property[];
+        lazyAncestorObjectTypes: () => readonly NamedObjectType[];
+        lazyChildObjectTypes: () => readonly NamedObjectType[];
+        lazyDiscriminantProperty: (namedObjectType: NamedObjectType) => NamedObjectType.DiscriminantProperty;
+        lazyIdentifierProperty: (namedObjectType: NamedObjectType) => NamedObjectType.IdentifierProperty;
+        lazyDescendantObjectTypes: () => readonly NamedObjectType[];
+        lazyParentObjectTypes: () => readonly NamedObjectType[];
+        lazyProperties: (namedObjectType: NamedObjectType) => readonly NamedObjectType.Property[];
         name: string;
         recursive: boolean;
         staticModuleName: string;
         synthetic: boolean;
         toRdfTypes: readonly NamedNode[];
     } & ConstructorParameters<typeof AbstractType>[0]);
-    get ancestorObjectTypes(): readonly ObjectType[];
-    get childObjectTypes(): readonly ObjectType[];
+    get _discriminantProperty(): NamedObjectType.DiscriminantProperty;
+    get ancestorObjectTypes(): readonly NamedObjectType[];
+    get childObjectTypes(): readonly NamedObjectType[];
     get conversions(): readonly AbstractType.Conversion[];
     get declaration(): Maybe<Code>;
     get descendantFromRdfTypeVariables(): readonly Code[];
     get descendantFromRdfTypes(): readonly NamedNode[];
-    get descendantObjectTypes(): readonly ObjectType[];
+    get descendantObjectTypes(): readonly NamedObjectType[];
     get discriminantProperty(): Maybe<AbstractType.DiscriminantProperty>;
     get discriminantValue(): string;
     get equalsFunction(): Code;
@@ -66,20 +67,19 @@ export declare class ObjectType extends AbstractType {
     get filterType(): Code;
     get fromRdfTypeVariable(): Maybe<Code>;
     get graphqlType(): AbstractType.GraphqlType;
-    get identifierProperty(): ObjectType.IdentifierProperty;
+    get identifierProperty(): NamedObjectType.IdentifierProperty;
     get identifierTypeAlias(): Code;
     get mutable(): boolean;
-    get objectSetMethodNames(): ObjectType.ObjectSetMethodNames;
-    get ownProperties(): readonly ObjectType.Property[];
-    get ownShaclProperties(): readonly ObjectType.ShaclProperty<Type>[];
-    get parentObjectTypes(): readonly ObjectType[];
-    get properties(): readonly ObjectType.Property[];
+    get objectSetMethodNames(): NamedObjectType.ObjectSetMethodNames;
+    get ownProperties(): readonly NamedObjectType.Property[];
+    get ownShaclProperties(): readonly NamedObjectType.ShaclProperty<Type>[];
+    get parentObjectTypes(): readonly NamedObjectType[];
+    get properties(): readonly NamedObjectType.Property[];
     get schema(): Code;
     get schemaType(): Code;
+    get toRdfjsResourceType(): Code;
     get valueSparqlConstructTriplesFunction(): Code;
     get valueSparqlWherePatternsFunction(): Code;
-    get toRdfjsResourceType(): Code;
-    get _discriminantProperty(): ObjectType.DiscriminantProperty;
     protected get thisVariable(): Code;
     fromJsonExpression({ variables, }: Parameters<AbstractType["fromJsonExpression"]>[0]): Code;
     fromRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["fromRdfResourceValuesExpression"]>[0]): Code;
@@ -89,9 +89,9 @@ export declare class ObjectType extends AbstractType {
         };
     }): Code;
     hashStatements({ variables, }: Parameters<AbstractType["hashStatements"]>[0]): readonly Code[];
+    jsonSchema({ context, }: Parameters<AbstractType["jsonSchema"]>[0]): Code;
     jsonType(): AbstractType.JsonType;
     jsonUiSchemaElement({ variables, }: Parameters<AbstractType["jsonUiSchemaElement"]>[0]): Maybe<Code>;
-    jsonZodSchema({ context, }: Parameters<AbstractType["jsonZodSchema"]>[0]): Code;
     newExpression({ parameters }: {
         parameters: Code;
     }): Code;
@@ -106,7 +106,7 @@ export declare class ObjectType extends AbstractType {
     private readonly lazyParentObjectTypes;
     private readonly lazyProperties;
 }
-export declare namespace ObjectType {
+export declare namespace NamedObjectType {
     const IdentifierPrefixProperty: typeof _IdentifierPrefixProperty;
     type IdentifierPrefixProperty = _IdentifierPrefixProperty;
     const IdentifierProperty: typeof _IdentifierProperty;
@@ -123,4 +123,4 @@ export declare namespace ObjectType {
     const DiscriminantProperty: typeof _DiscriminantProperty;
     type DiscriminantProperty = _DiscriminantProperty;
 }
-//# sourceMappingURL=ObjectType.d.ts.map
+//# sourceMappingURL=NamedObjectType.d.ts.map

package/dist/generators/ts/{ObjectType.js → NamedObjectType.js}

@@ -7,46 +7,45 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { camelCase } from "change-case";
 import { Maybe, NonEmptyList } from "purify-ts";
 import { Memoize } from "typescript-memoize";
-import { DiscriminantProperty as _DiscriminantProperty } from "./_ObjectType/DiscriminantProperty.js";
-import { IdentifierPrefixProperty as _IdentifierPrefixProperty } from "./_ObjectType/IdentifierPrefixProperty.js";
-import { IdentifierProperty as _IdentifierProperty } from "./_ObjectType/IdentifierProperty.js";
-import { identifierTypeDeclarations } from "./_ObjectType/identifierTypeDeclarations.js";
-import { ObjectType_classDeclaration } from "./_ObjectType/ObjectType_classDeclaration.js";
-import { ObjectType_createFunctionDeclaration } from "./_ObjectType/ObjectType_createFunctionDeclaration.js";
-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_focusSparqlConstructTriplesFunctionDeclaration } from "./_ObjectType/ObjectType_focusSparqlConstructTriplesFunctionDeclaration.js";
-import { ObjectType_focusSparqlWherePatternsFunctionDeclaration } from "./_ObjectType/ObjectType_focusSparqlWherePatternsFunctionDeclaration.js";
-import { ObjectType_fromJsonFunctionDeclaration } from "./_ObjectType/ObjectType_fromJsonFunctionDeclaration.js";
-import { ObjectType_fromRdfResourceFunctionDeclaration } from "./_ObjectType/ObjectType_fromRdfResourceFunctionDeclaration.js";
-import { ObjectType_fromRdfResourceValuesFunctionDeclaration } from "./_ObjectType/ObjectType_fromRdfResourceValuesFunctionDeclaration.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_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_parseJsonFunctionDeclaration } from "./_ObjectType/ObjectType_parseJsonFunctionDeclaration.js";
-import { ObjectType_propertiesFromJsonFunctionDeclaration } from "./_ObjectType/ObjectType_propertiesFromJsonFunctionDeclaration.js";
-import { ObjectType_propertiesFromRdfResourceFunctionDeclaration } from "./_ObjectType/ObjectType_propertiesFromRdfResourceFunctionDeclaration.js";
-import { ObjectType_schemaVariableStatement } from "./_ObjectType/ObjectType_schemaVariableStatement.js";
-import { ObjectType_sparqlConstructQueryFunctionDeclaration } from "./_ObjectType/ObjectType_sparqlConstructQueryFunctionDeclaration.js";
-import { ObjectType_sparqlConstructQueryStringFunctionDeclaration } from "./_ObjectType/ObjectType_sparqlConstructQueryStringFunctionDeclaration.js";
-import { ObjectType_toJsonFunctionOrMethodDeclaration } from "./_ObjectType/ObjectType_toJsonFunctionOrMethodDeclaration.js";
-import { ObjectType_toRdfResourceFunctionOrMethodDeclaration } from "./_ObjectType/ObjectType_toRdfResourceFunctionOrMethodDeclaration.js";
-import { ObjectType_valueSparqlConstructTriplesFunctionDeclaration } from "./_ObjectType/ObjectType_valueSparqlConstructTriplesFunctionDeclaration.js";
-import { ObjectType_valueSparqlWherePatternsFunctionDeclaration } from "./_ObjectType/ObjectType_valueSparqlWherePatternsFunctionDeclaration.js";
-import { ShaclProperty as _ShaclProperty } from "./_ObjectType/ShaclProperty.js";
+import { DiscriminantProperty as _DiscriminantProperty } from "./_NamedObjectType/DiscriminantProperty.js";
+import { IdentifierPrefixProperty as _IdentifierPrefixProperty } from "./_NamedObjectType/IdentifierPrefixProperty.js";
+import { IdentifierProperty as _IdentifierProperty } from "./_NamedObjectType/IdentifierProperty.js";
+import { identifierTypeDeclarations } from "./_NamedObjectType/identifierTypeDeclarations.js";
+import { NamedObjectType_classDeclaration } from "./_NamedObjectType/NamedObjectType_classDeclaration.js";
+import { NamedObjectType_createFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_createFunctionDeclaration.js";
+import { NamedObjectType_equalsFunctionOrMethodDeclaration } from "./_NamedObjectType/NamedObjectType_equalsFunctionOrMethodDeclaration.js";
+import { NamedObjectType_filterFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_filterFunctionDeclaration.js";
+import { NamedObjectType_filterTypeDeclaration } from "./_NamedObjectType/NamedObjectType_filterTypeDeclaration.js";
+import { NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration.js";
+import { NamedObjectType_focusSparqlWherePatternsFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_focusSparqlWherePatternsFunctionDeclaration.js";
+import { NamedObjectType_fromJsonFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_fromJsonFunctionDeclaration.js";
+import { NamedObjectType_fromRdfResourceFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_fromRdfResourceFunctionDeclaration.js";
+import { NamedObjectType_fromRdfResourceValuesFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_fromRdfResourceValuesFunctionDeclaration.js";
+import { NamedObjectType_fromRdfTypeVariableStatement } from "./_NamedObjectType/NamedObjectType_fromRdfTypeVariableStatement.js";
+import { NamedObjectType_graphqlTypeVariableStatement } from "./_NamedObjectType/NamedObjectType_graphqlTypeVariableStatement.js";
+import { NamedObjectType_hashFunctionOrMethodDeclarations } from "./_NamedObjectType/NamedObjectType_hashFunctionOrMethodDeclarations.js";
+import { NamedObjectType_interfaceDeclaration } from "./_NamedObjectType/NamedObjectType_interfaceDeclaration.js";
+import { NamedObjectType_isTypeFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_isTypeFunctionDeclaration.js";
+import { NamedObjectType_jsonParseFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_jsonParseFunctionDeclaration.js";
+import { NamedObjectType_jsonSchemaFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_jsonSchemaFunctionDeclaration.js";
+import { NamedObjectType_jsonTypeAliasDeclaration } from "./_NamedObjectType/NamedObjectType_jsonTypeAliasDeclaration.js";
+import { NamedObjectType_jsonUiSchemaFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_jsonUiSchemaFunctionDeclaration.js";
+import { NamedObjectType_objectSetMethodNames } from "./_NamedObjectType/NamedObjectType_objectSetMethodNames.js";
+import { NamedObjectType_propertiesFromJsonFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_propertiesFromJsonFunctionDeclaration.js";
+import { NamedObjectType_propertiesFromRdfResourceFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_propertiesFromRdfResourceFunctionDeclaration.js";
+import { NamedObjectType_schemaVariableStatement } from "./_NamedObjectType/NamedObjectType_schemaVariableStatement.js";
+import { NamedObjectType_sparqlConstructQueryFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_sparqlConstructQueryFunctionDeclaration.js";
+import { NamedObjectType_sparqlConstructQueryStringFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.js";
+import { NamedObjectType_toJsonFunctionOrMethodDeclaration } from "./_NamedObjectType/NamedObjectType_toJsonFunctionOrMethodDeclaration.js";
+import { NamedObjectType_toRdfResourceFunctionOrMethodDeclaration } from "./_NamedObjectType/NamedObjectType_toRdfResourceFunctionOrMethodDeclaration.js";
+import { NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration.js";
+import { NamedObjectType_valueSparqlWherePatternsFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_valueSparqlWherePatternsFunctionDeclaration.js";
+import { ShaclProperty as _ShaclProperty } from "./_NamedObjectType/ShaclProperty.js";
 import { AbstractType } from "./AbstractType.js";
 import { imports } from "./imports.js";
 import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code, def, joinCode } from "./ts-poet-wrapper.js";
-export class ObjectType extends AbstractType {
+export class NamedObjectType extends AbstractType {
     imports;
     toRdfTypes;
     abstract;
@@ -56,7 +55,7 @@ export class ObjectType extends AbstractType {
     fromRdfType;
     graphqlArgs = Maybe.empty();
     identifierType;
-    kind = "ObjectType";
+    kind = "NamedObjectType";
     name;
     recursive;
     staticModuleName;
@@ -85,6 +84,9 @@ export class ObjectType extends AbstractType {
         this.synthetic = synthetic;
         this.toRdfTypes = toRdfTypes;
     }
+    get _discriminantProperty() {
+        return this.lazyDiscriminantProperty(this);
+    }
     get ancestorObjectTypes() {
         return this.lazyAncestorObjectTypes();
     }
@@ -110,20 +112,29 @@ export class ObjectType extends AbstractType {
             const staticModuleDeclarations = [];
             switch (this.declarationType) {
                 case "class": {
-                    declarations.push(ObjectType_classDeclaration.call(this));
+                    declarations.push(NamedObjectType_classDeclaration.call(this));
                     break;
                 }
                 case "interface": {
-                    declarations.push(ObjectType_interfaceDeclaration.call(this));
-                    staticModuleDeclarations.push(...ObjectType_createFunctionDeclaration.call(this).toList(), ...ObjectType_equalsFunctionOrMethodDeclaration.bind(this)().toList(), ...ObjectType_hashFunctionOrMethodDeclarations.call(this));
+                    declarations.push(NamedObjectType_interfaceDeclaration.call(this));
+                    staticModuleDeclarations.push(...NamedObjectType_createFunctionDeclaration.call(this).toList(), ...NamedObjectType_equalsFunctionOrMethodDeclaration.bind(this)().toList(), ...NamedObjectType_hashFunctionOrMethodDeclarations.call(this));
                     break;
                 }
             }
-            staticModuleDeclarations.push(...ObjectType_graphqlTypeVariableStatement.call(this).toList(), ...identifierTypeDeclarations.call(this), ...ObjectType_jsonTypeAliasDeclaration.call(this).toList(), ObjectType_filterFunctionDeclaration.call(this), ObjectType_filterTypeDeclaration.call(this), ...ObjectType_focusSparqlConstructTriplesFunctionDeclaration.bind(this)().toList(), ...ObjectType_focusSparqlWherePatternsFunctionDeclaration.bind(this)().toList(), ...ObjectType_fromJsonFunctionDeclaration.call(this).toList(), ...ObjectType_fromRdfResourceFunctionDeclaration.call(this).toList(), ...ObjectType_fromRdfResourceValuesFunctionDeclaration.call(this).toList(), ...ObjectType_fromRdfTypeVariableStatement.call(this).toList(), ObjectType_isTypeFunctionDeclaration.call(this), ...ObjectType_jsonSchemaFunctionDeclaration.call(this).toList(), ...ObjectType_jsonUiSchemaFunctionDeclaration.call(this).toList(), ...ObjectType_jsonZodSchemaFunctionDeclaration.call(this).toList(), ...ObjectType_parseJsonFunctionDeclaration.call(this).toList(), ...ObjectType_propertiesFromJsonFunctionDeclaration.bind(this)().toList(), ...ObjectType_propertiesFromRdfResourceFunctionDeclaration.bind(this)().toList(), ObjectType_schemaVariableStatement.call(this), ...ObjectType_sparqlConstructQueryFunctionDeclaration.bind(this)().toList(), ...ObjectType_sparqlConstructQueryStringFunctionDeclaration.bind(this)().toList(), ...(this.declarationType === "interface"
-                ? ObjectType_toJsonFunctionOrMethodDeclaration.call(this).toList()
+            const jsonModuleDeclarations = [
+                ...NamedObjectType_jsonParseFunctionDeclaration.call(this).toList(),
+                ...NamedObjectType_jsonSchemaFunctionDeclaration.call(this).toList(),
+                ...NamedObjectType_jsonUiSchemaFunctionDeclaration.call(this).toList(),
+            ];
+            staticModuleDeclarations.push(...NamedObjectType_graphqlTypeVariableStatement.call(this).toList(), ...identifierTypeDeclarations.call(this), ...NamedObjectType_jsonTypeAliasDeclaration.call(this).toList(), ...(jsonModuleDeclarations.length > 0
+                ? [
+                    code `export namespace ${syntheticNamePrefix}Json { ${joinCode(jsonModuleDeclarations, { on: "\n\n" })} }`,
+                ]
+                : []), NamedObjectType_filterFunctionDeclaration.call(this), NamedObjectType_filterTypeDeclaration.call(this), ...NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_focusSparqlWherePatternsFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_fromJsonFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfResourceFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfResourceValuesFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfTypeVariableStatement.call(this).toList(), NamedObjectType_isTypeFunctionDeclaration.call(this), ...NamedObjectType_propertiesFromJsonFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_propertiesFromRdfResourceFunctionDeclaration.bind(this)().toList(), NamedObjectType_schemaVariableStatement.call(this), ...NamedObjectType_sparqlConstructQueryFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.bind(this)().toList(), ...(this.declarationType === "interface"
+                ? NamedObjectType_toJsonFunctionOrMethodDeclaration.call(this).toList()
                 : []), ...(this.declarationType === "interface"
-                ? ObjectType_toRdfResourceFunctionOrMethodDeclaration.call(this).toList()
-                : []), ...ObjectType_valueSparqlConstructTriplesFunctionDeclaration.bind(this)().toList(), ...ObjectType_valueSparqlWherePatternsFunctionDeclaration.bind(this)().toList());
+                ? NamedObjectType_toRdfResourceFunctionOrMethodDeclaration.call(this).toList()
+                : []), ...NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_valueSparqlWherePatternsFunctionDeclaration.bind(this)().toList());
             if (staticModuleDeclarations.length > 0) {
                 declarations.push(code `\
 export namespace ${def(this.staticModuleName)} {
@@ -184,7 +195,7 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
         return this.properties.some((property) => property.mutable);
     }
     get objectSetMethodNames() {
-        return ObjectType_objectSetMethodNames.call(this);
+        return NamedObjectType_objectSetMethodNames.call(this);
     }
     get ownProperties() {
         if (this.parentObjectTypes.length === 0) {
@@ -217,20 +228,17 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
     get schemaType() {
         return code `typeof ${this.schema}`;
     }
-    get valueSparqlConstructTriplesFunction() {
-        return code `${this.staticModuleName}.${syntheticNamePrefix}valueSparqlConstructTriples`;
-    }
-    get valueSparqlWherePatternsFunction() {
-        return code `${this.staticModuleName}.${syntheticNamePrefix}valueSparqlWherePatterns`;
-    }
     get toRdfjsResourceType() {
         if (this.parentObjectTypes.length > 0) {
             return this.parentObjectTypes[0].toRdfjsResourceType;
         }
         return code `${imports.Resource}${this.identifierType.kind === "IriType" ? code `<${imports.NamedNode}>` : ""}`;
     }
-    get _discriminantProperty() {
-        return this.lazyDiscriminantProperty(this);
+    get valueSparqlConstructTriplesFunction() {
+        return code `${this.staticModuleName}.${syntheticNamePrefix}valueSparqlConstructTriples`;
+    }
+    get valueSparqlWherePatternsFunction() {
+        return code `${this.staticModuleName}.${syntheticNamePrefix}valueSparqlWherePatterns`;
     }
     get thisVariable() {
         switch (this.declarationType) {
@@ -265,20 +273,20 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
                 ];
         }
     }
-    jsonType() {
-        return new AbstractType.JsonType(code `${this.staticModuleName}.${syntheticNamePrefix}Json`);
-    }
-    jsonUiSchemaElement({ variables, }) {
-        return Maybe.of(code `${this.staticModuleName}.${syntheticNamePrefix}jsonUiSchema({ scopePrefix: ${variables.scopePrefix} })`);
-    }
-    jsonZodSchema({ context, }) {
-        let expression = code `${this.staticModuleName}.${syntheticNamePrefix}jsonZodSchema()`;
+    jsonSchema({ context, }) {
+        let expression = code `${this.staticModuleName}.${syntheticNamePrefix}Json.schema()`;
         if (context === "property" &&
             this.properties.some((property) => property.recursive)) {
             expression = code `${imports.z}.lazy((): ${imports.z}.ZodType<${this.staticModuleName}.${syntheticNamePrefix}Json> => ${expression})`;
         }
         return expression;
     }
+    jsonType() {
+        return new AbstractType.JsonType(code `${this.staticModuleName}.${syntheticNamePrefix}Json`);
+    }
+    jsonUiSchemaElement({ variables, }) {
+        return Maybe.of(code `${this.staticModuleName}.${syntheticNamePrefix}Json.uiSchema({ scopePrefix: ${variables.scopePrefix} })`);
+    }
     newExpression({ parameters }) {
         switch (this.declarationType) {
             case "class":
@@ -318,95 +326,95 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
 }
 __decorate([
     Memoize()
-], ObjectType.prototype, "ancestorObjectTypes", null);
+], NamedObjectType.prototype, "_discriminantProperty", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "childObjectTypes", null);
+], NamedObjectType.prototype, "ancestorObjectTypes", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "conversions", null);
+], NamedObjectType.prototype, "childObjectTypes", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "descendantFromRdfTypeVariables", null);
+], NamedObjectType.prototype, "conversions", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "descendantFromRdfTypes", null);
+], NamedObjectType.prototype, "descendantFromRdfTypeVariables", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "descendantObjectTypes", null);
+], NamedObjectType.prototype, "descendantFromRdfTypes", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "discriminantProperty", null);
+], NamedObjectType.prototype, "descendantObjectTypes", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "discriminantValue", null);
+], NamedObjectType.prototype, "discriminantProperty", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "equalsFunction", null);
+], NamedObjectType.prototype, "discriminantValue", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "filterFunction", null);
+], NamedObjectType.prototype, "equalsFunction", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "filterType", null);
+], NamedObjectType.prototype, "filterFunction", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "fromRdfTypeVariable", null);
+], NamedObjectType.prototype, "filterType", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "graphqlType", null);
+], NamedObjectType.prototype, "fromRdfTypeVariable", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "identifierProperty", null);
+], NamedObjectType.prototype, "graphqlType", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "identifierTypeAlias", null);
+], NamedObjectType.prototype, "identifierProperty", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "mutable", null);
+], NamedObjectType.prototype, "identifierTypeAlias", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "objectSetMethodNames", null);
+], NamedObjectType.prototype, "mutable", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "ownProperties", null);
+], NamedObjectType.prototype, "objectSetMethodNames", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "ownShaclProperties", null);
+], NamedObjectType.prototype, "ownProperties", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "parentObjectTypes", null);
+], NamedObjectType.prototype, "ownShaclProperties", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "properties", null);
+], NamedObjectType.prototype, "parentObjectTypes", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "schema", null);
+], NamedObjectType.prototype, "properties", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "schemaType", null);
+], NamedObjectType.prototype, "schema", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "valueSparqlConstructTriplesFunction", null);
+], NamedObjectType.prototype, "schemaType", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "valueSparqlWherePatternsFunction", null);
+], NamedObjectType.prototype, "toRdfjsResourceType", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "toRdfjsResourceType", null);
+], NamedObjectType.prototype, "valueSparqlConstructTriplesFunction", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "_discriminantProperty", null);
+], NamedObjectType.prototype, "valueSparqlWherePatternsFunction", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "thisVariable", null);
+], NamedObjectType.prototype, "thisVariable", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "jsonType", null);
-(function (ObjectType) {
-    ObjectType.IdentifierPrefixProperty = _IdentifierPrefixProperty;
-    ObjectType.IdentifierProperty = _IdentifierProperty;
-    ObjectType.ShaclProperty = _ShaclProperty;
-    ObjectType.DiscriminantProperty = _DiscriminantProperty;
-})(ObjectType || (ObjectType = {}));
-//# sourceMappingURL=ObjectType.js.map
+], NamedObjectType.prototype, "jsonType", null);
+(function (NamedObjectType) {
+    NamedObjectType.IdentifierPrefixProperty = _IdentifierPrefixProperty;
+    NamedObjectType.IdentifierProperty = _IdentifierProperty;
+    NamedObjectType.ShaclProperty = _ShaclProperty;
+    NamedObjectType.DiscriminantProperty = _DiscriminantProperty;
+})(NamedObjectType || (NamedObjectType = {}));
+//# sourceMappingURL=NamedObjectType.js.map

package/dist/generators/ts/NamedObjectUnionType.d.ts

@@ -3,18 +3,18 @@ import { AbstractType } from "./AbstractType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
 import type { IdentifierType } from "./IdentifierType.js";
 import type { IriType } from "./IriType.js";
-import type { ObjectType } from "./ObjectType.js";
+import type { NamedObjectType } from "./NamedObjectType.js";
 import { type Code } from "./ts-poet-wrapper.js";
-export declare class NamedObjectUnionType extends AbstractNamedUnionType<ObjectType> {
+export declare class NamedObjectUnionType extends AbstractNamedUnionType<NamedObjectType> {
     #private;
     readonly graphqlArgs: AbstractType["graphqlArgs"];
     readonly kind = "NamedObjectUnionType";
     constructor({ identifierType, ...superParameters }: {
         identifierType: BlankNodeType | IdentifierType | IriType;
-    } & Omit<ConstructorParameters<typeof AbstractNamedUnionType<ObjectType>>[0], "identifierType">);
+    } & Omit<ConstructorParameters<typeof AbstractNamedUnionType<NamedObjectType>>[0], "identifierType">);
     get graphqlType(): AbstractType.GraphqlType;
     get identifierTypeAlias(): Code;
-    get objectSetMethodNames(): ObjectType.ObjectSetMethodNames;
+    get objectSetMethodNames(): NamedObjectType.ObjectSetMethodNames;
     get schema(): Code;
     get schemaType(): Code;
     protected get staticModuleDeclarations(): Record<string, Code>;

package/dist/generators/ts/NamedObjectUnionType.js

@@ -8,20 +8,16 @@ import { pascalCase } from "change-case";
 import { Maybe } from "purify-ts";
 import { PropertyPath } from "rdfjs-resource";
 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 { NamedObjectType_objectSetMethodNames } from "./_NamedObjectType/NamedObjectType_objectSetMethodNames.js";
+import { NamedObjectType_sparqlConstructQueryFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_sparqlConstructQueryFunctionDeclaration.js";
+import { NamedObjectType_sparqlConstructQueryStringFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.js";
 import { AbstractNamedUnionType } from "./AbstractNamedUnionType.js";
 import { AbstractType } from "./AbstractType.js";
 import { imports } from "./imports.js";
+import { singleEntryRecord } from "./singleEntryRecord.js";
 import { snippets } from "./snippets.js";
 import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
-function singleEntryRecord(key, value) {
-    const record = {};
-    record[key] = value;
-    return record;
-}
 export class NamedObjectUnionType extends AbstractNamedUnionType {
     #identifierType;
     graphqlArgs = Maybe.empty();
@@ -37,7 +33,7 @@ export class NamedObjectUnionType extends AbstractNamedUnionType {
         return code `${this.staticModuleName}.${syntheticNamePrefix}Identifier`;
     }
     get objectSetMethodNames() {
-        return ObjectType_objectSetMethodNames.call(this);
+        return NamedObjectType_objectSetMethodNames.call(this);
     }
     get schema() {
         return code `${this.staticModuleName}.${syntheticNamePrefix}schema`;
@@ -55,10 +51,10 @@ export class NamedObjectUnionType extends AbstractNamedUnionType {
             ...this.graphqlTypeVariableStatement,
             ...this.isTypeFunctionDeclaration,
             ...this.schemaVariableStatement,
-            ...ObjectType_sparqlConstructQueryFunctionDeclaration.call(this)
+            ...NamedObjectType_sparqlConstructQueryFunctionDeclaration.call(this)
                 .map((code_) => singleEntryRecord(`${syntheticNamePrefix}sparqlConstructQuery`, code_))
                 .orDefault({}),
-            ...ObjectType_sparqlConstructQueryStringFunctionDeclaration.call(this)
+            ...NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.call(this)
                 .map((code_) => singleEntryRecord(`${syntheticNamePrefix}sparqlConstructQueryString`, code_))
                 .orDefault({}),
             ...this.toRdfResourceFunctionDeclaration,
@@ -181,7 +177,7 @@ ${{
         if (!this.features.has("rdf")) {
             return {};
         }
-        return singleEntryRecord(``, code `\
+        return singleEntryRecord(`${syntheticNamePrefix}toRdfResource`, code `\
 export const ${syntheticNamePrefix}toRdfResource: ${snippets.ToRdfResourceFunction}<${this.name}> = (value, options) => {
 ${joinCode(this.concreteMembers
             .map((member) => {

package/dist/generators/ts/OptionType.d.ts

@@ -26,7 +26,7 @@ export declare class OptionType<ItemTypeT extends OptionType.ItemType> extends A
     hashStatements({ depth, variables, }: Parameters<AbstractContainerType<ItemTypeT>["hashStatements"]>[0]): readonly Code[];
     jsonType(parameters?: Parameters<AbstractContainerType<ItemTypeT>["jsonType"]>[0]): AbstractContainerType.JsonType;
     jsonUiSchemaElement(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonUiSchemaElement"]>[0]): Maybe<Code>;
-    jsonZodSchema(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonZodSchema"]>[0]): Code;
+    jsonSchema(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonSchema"]>[0]): Code;
     toJsonExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["toJsonExpression"]>[0]): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["toRdfResourceValuesExpression"]>[0]): Code;
 }

package/dist/generators/ts/OptionType.js

@@ -122,8 +122,8 @@ export class OptionType extends AbstractContainerType {
     jsonUiSchemaElement(parameters) {
         return this.itemType.jsonUiSchemaElement(parameters);
     }
-    jsonZodSchema(parameters) {
-        return code `${this.itemType.jsonZodSchema(parameters)}.optional()`;
+    jsonSchema(parameters) {
+        return code `${this.itemType.jsonSchema(parameters)}.optional()`;
     }
     toJsonExpression({ variables, }) {
         return code `${variables.value}.map(item => (${this.itemType.toJsonExpression({ variables: { value: code `item` } })})).extract()`;

package/dist/generators/ts/StringType.d.ts

@@ -16,7 +16,7 @@ export declare class StringType extends AbstractPrimitiveType<string> {
         kind: Code;
     };
     hashStatements({ variables, }: Parameters<AbstractPrimitiveType<string>["hashStatements"]>[0]): readonly Code[];
-    jsonZodSchema(_parameters: Parameters<AbstractPrimitiveType<string>["jsonZodSchema"]>[0]): Code;
+    jsonSchema(_parameters: Parameters<AbstractPrimitiveType<string>["jsonSchema"]>[0]): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<string>["toRdfResourceValuesExpression"]>[0]): Code;
     protected fromRdfExpressionChain({ variables, }: Parameters<AbstractPrimitiveType<string>["fromRdfExpressionChain"]>[0]): ReturnType<AbstractPrimitiveType<string>["fromRdfExpressionChain"]>;
 }

package/dist/generators/ts/StringType.js

@@ -37,7 +37,7 @@ export class StringType extends AbstractPrimitiveType {
     hashStatements({ variables, }) {
         return [code `${variables.hasher}.update(${variables.value});`];
     }
-    jsonZodSchema(_parameters) {
+    jsonSchema(_parameters) {
         switch (this.primitiveIn.length) {
             case 0:
                 return code `${imports.z}.string()`;