@shaclmate/compiler 4.0.9 → 4.0.11

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()`;

package/dist/generators/ts/TermType.d.ts

@@ -21,7 +21,7 @@ export declare class TermType<ConstantTermT extends Literal | NamedNode = Litera
     fromJsonExpression({ variables, }: Parameters<AbstractTermType["fromJsonExpression"]>[0]): Code;
     graphqlResolveExpression(_parameters: Parameters<AbstractTermType["graphqlResolveExpression"]>[0]): Code;
     jsonType(): AbstractTermType.JsonType;
-    jsonZodSchema(_parameters: Parameters<AbstractTermType["jsonZodSchema"]>[0]): Code;
+    jsonSchema(_parameters: Parameters<AbstractTermType["jsonSchema"]>[0]): Code;
     toJsonExpression({ variables, }: Parameters<AbstractTermType["toJsonExpression"]>[0]): Code;
 }
 //# sourceMappingURL=TermType.d.ts.map

package/dist/generators/ts/TermType.js

@@ -82,7 +82,7 @@ export class TermType extends AbstractTermType {
             .map((nodeKind) => `"${NodeKind.toTermType(nodeKind)}"`)
             .join(" | ")} } | { readonly "@language"?: string, readonly "@type"?: string, readonly "@value": string, readonly termType: "Literal" }`);
     }
-    jsonZodSchema(_parameters) {
+    jsonSchema(_parameters) {
         return code `${imports.z}.discriminatedUnion("termType", [${joinCode([...this.nodeKinds].map((nodeKind) => {
             switch (nodeKind) {
                 case "BlankNode":

package/dist/generators/ts/TsGenerator.js

@@ -15,31 +15,31 @@ export class TsGenerator {
             }
             declarations = declarations.concat(this.typeFactory.createType(astNamedUnionType).declaration.toList());
         }
-        const objectTypesToposorted = ast.ObjectType.toposort(ast_.objectTypes).map((astObjectType) => this.typeFactory.createObjectType(astObjectType));
+        const namedObjectTypesToposorted = ast.ObjectType.toposort(ast_.namedObjectTypes).map((astObjectType) => this.typeFactory.createNamedObjectType(astObjectType));
         const namedObjectUnionTypesToposorted = ast_.namedUnionTypes
             .filter((_) => _.isObjectUnionType())
             .map((astObjectUnionType) => this.typeFactory.createNamedObjectUnionType(astObjectUnionType));
-        for (const objectType of objectTypesToposorted) {
-            declarations = declarations.concat(objectType.declaration.toList());
+        for (const namedObjectType of namedObjectTypesToposorted) {
+            declarations = declarations.concat(namedObjectType.declaration.toList());
         }
         for (const namedObjectUnionType of namedObjectUnionTypesToposorted) {
             declarations = declarations.concat(namedObjectUnionType.declaration.toList());
         }
-        const objectTypesNameSorted = objectTypesToposorted.toSorted((left, right) => left.name.localeCompare(right.name));
+        const namedObjectTypesNameSorted = namedObjectTypesToposorted.toSorted((left, right) => left.name.localeCompare(right.name));
         const namedObjectUnionTypesNameSorted = namedObjectUnionTypesToposorted.toSorted((left, right) => left.name.localeCompare(right.name));
-        if (objectTypesToposorted.length > 0) {
+        if (namedObjectTypesToposorted.length > 0) {
             const uberObjectUnionType = synthesizeUberObjectUnionType({
-                objectTypes: objectTypesToposorted.toReversed(), // Reverse topological order so children ane before parents
+                namedObjectTypes: namedObjectTypesToposorted.toReversed(), // Reverse topological order so children ane before parents
             });
             declarations = declarations.concat(uberObjectUnionType.declaration.toList());
             namedObjectUnionTypesNameSorted.push(uberObjectUnionType);
         }
         declarations.push(...objectSetDeclarations({
-            objectTypes: objectTypesNameSorted,
+            namedObjectTypes: namedObjectTypesNameSorted,
             namedObjectUnionTypes: namedObjectUnionTypesNameSorted,
         }));
         declarations.push(...graphqlSchemaVariableStatement({
-            objectTypes: objectTypesNameSorted,
+            namedObjectTypes: namedObjectTypesNameSorted,
             namedObjectUnionTypes: namedObjectUnionTypesNameSorted,
         }).toList());
         declarations.splice(0, 0, joinCode(Object.values(snippets)

package/dist/generators/ts/Type.d.ts

@@ -15,12 +15,12 @@ import type { LazyObjectSetType } from "./LazyObjectSetType.js";
 import type { LazyObjectType } from "./LazyObjectType.js";
 import type { ListType } from "./ListType.js";
 import type { LiteralType } from "./LiteralType.js";
+import type { NamedObjectType } from "./NamedObjectType.js";
 import type { NamedObjectUnionType } from "./NamedObjectUnionType.js";
 import type { NamedUnionType } from "./NamedUnionType.js";
-import type { ObjectType } from "./ObjectType.js";
 import type { OptionType } from "./OptionType.js";
 import type { SetType } from "./SetType.js";
 import type { StringType } from "./StringType.js";
 import type { TermType } from "./TermType.js";
-export type Type = AnonymousUnionType | BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | DefaultValueType<DefaultValueType.ItemType> | FloatType | IdentifierType | IntType | IriType | LazyObjectOptionType | LazyObjectSetType | LazyObjectType | ListType<ListType.ItemType> | LiteralType | NamedObjectUnionType | NamedUnionType | ObjectType | OptionType<OptionType.ItemType> | SetType<SetType.ItemType> | StringType | TermType;
+export type Type = AnonymousUnionType | BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | DefaultValueType<DefaultValueType.ItemType> | FloatType | IdentifierType | IntType | IriType | LazyObjectOptionType | LazyObjectSetType | LazyObjectType | ListType<ListType.ItemType> | LiteralType | NamedObjectUnionType | NamedUnionType | NamedObjectType | OptionType<OptionType.ItemType> | SetType<SetType.ItemType> | StringType | TermType;
 //# sourceMappingURL=Type.d.ts.map

package/dist/generators/ts/TypeFactory.d.ts

@@ -1,16 +1,16 @@
 import type { Literal, NamedNode } from "@rdfjs/types";
 import * as ast from "../../ast/index.js";
 import { AnonymousUnionType } from "./AnonymousUnionType.js";
+import { NamedObjectType } from "./NamedObjectType.js";
 import { NamedObjectUnionType } from "./NamedObjectUnionType.js";
 import { NamedUnionType } from "./NamedUnionType.js";
-import { ObjectType } from "./ObjectType.js";
 import type { Type } from "./Type.js";
 export declare class TypeFactory {
     private cachedNamedObjectUnionTypesByShapeIdentifier;
     private cachedObjectTypePropertiesByShapeIdentifier;
     private cachedObjectTypesByShapeIdentifier;
     createNamedObjectUnionType(astType: ast.ObjectUnionType): NamedObjectUnionType;
-    createObjectType(astType: ast.ObjectType): ObjectType;
+    createNamedObjectType(astType: ast.ObjectType): NamedObjectType;
     createType(astType: ast.Type, parameters?: {
         defaultValue?: Literal | NamedNode;
     }): Type;

package/dist/generators/ts/TypeFactory.js

@@ -25,9 +25,9 @@ import { LazyObjectSetType } from "./LazyObjectSetType.js";
 import { LazyObjectType } from "./LazyObjectType.js";
 import { ListType } from "./ListType.js";
 import { LiteralType } from "./LiteralType.js";
+import { NamedObjectType } from "./NamedObjectType.js";
 import { NamedObjectUnionType } from "./NamedObjectUnionType.js";
 import { NamedUnionType } from "./NamedUnionType.js";
-import { ObjectType } from "./ObjectType.js";
 import { OptionType } from "./OptionType.js";
 import { SetType } from "./SetType.js";
 import { StringType } from "./StringType.js";
@@ -50,9 +50,9 @@ export class TypeFactory {
             features: astType.tsFeatures,
             identifierType: this.createIdentifierType(ast.ObjectCompoundType.identifierType(astType)),
             label: astType.label,
-            members: ast.ObjectCompoundType.memberObjectTypes(astType).map((objectType) => ({
+            members: ast.ObjectCompoundType.memberObjectTypes(astType).map((namedObjectType) => ({
                 discriminantValue: Maybe.empty(),
-                type: this.createObjectType(objectType),
+                type: this.createNamedObjectType(namedObjectType),
             })),
             name: tsName(astType.name.unsafeCoerce()),
             recursive: astType.recursive,
@@ -60,7 +60,7 @@ export class TypeFactory {
         this.cachedNamedObjectUnionTypesByShapeIdentifier.set(astType.shapeIdentifier, namedObjectUnionType);
         return namedObjectUnionType;
     }
-    createObjectType(astType) {
+    createNamedObjectType(astType) {
         {
             const cachedObjectType = this.cachedObjectTypesByShapeIdentifier.get(astType.shapeIdentifier);
             if (cachedObjectType) {
@@ -72,7 +72,7 @@ export class TypeFactory {
             synthetic: astType.synthetic,
         });
         const staticModuleName = astType.childObjectTypes.length > 0 ? `${name}Static` : name;
-        const objectType = new ObjectType({
+        const namedObjectType = new NamedObjectType({
             abstract: astType.abstract,
             comment: astType.comment,
             declarationType: astType.tsObjectDeclarationType,
@@ -82,24 +82,24 @@ export class TypeFactory {
             identifierType,
             imports: astType.tsImports,
             label: astType.label,
-            lazyAncestorObjectTypes: () => astType.ancestorObjectTypes.map((astType) => this.createObjectType(astType)),
-            lazyChildObjectTypes: () => astType.childObjectTypes.map((astType) => this.createObjectType(astType)),
-            lazyDescendantObjectTypes: () => astType.descendantObjectTypes.map((astType) => this.createObjectType(astType)),
-            lazyDiscriminantProperty: (objectType) => {
+            lazyAncestorObjectTypes: () => astType.ancestorObjectTypes.map((astType) => this.createNamedObjectType(astType)),
+            lazyChildObjectTypes: () => astType.childObjectTypes.map((astType) => this.createNamedObjectType(astType)),
+            lazyDescendantObjectTypes: () => astType.descendantObjectTypes.map((astType) => this.createNamedObjectType(astType)),
+            lazyDiscriminantProperty: (namedObjectType) => {
                 // Discriminant property
                 const discriminantOwnValue = !astType.abstract
-                    ? objectType.discriminantValue
+                    ? namedObjectType.discriminantValue
                     : undefined;
                 const discriminantDescendantValues = new Set();
-                for (const descendantObjectType of objectType.descendantObjectTypes) {
+                for (const descendantObjectType of namedObjectType.descendantObjectTypes) {
                     if (!descendantObjectType.abstract) {
                         discriminantDescendantValues.add(descendantObjectType.discriminantValue);
                     }
                 }
-                return new ObjectType.DiscriminantProperty({
+                return new NamedObjectType.DiscriminantProperty({
                     name: `${syntheticNamePrefix}type`,
-                    objectType,
-                    type: new ObjectType.DiscriminantProperty.Type({
+                    namedObjectType,
+                    type: new NamedObjectType.DiscriminantProperty.Type({
                         descendantValues: [...discriminantDescendantValues].sort(),
                         mutable: false,
                         ownValues: discriminantOwnValue ? [discriminantOwnValue] : [],
@@ -107,17 +107,17 @@ export class TypeFactory {
                     visibility: "public",
                 });
             },
-            lazyIdentifierProperty: (objectType) => new ObjectType.IdentifierProperty({
+            lazyIdentifierProperty: (namedObjectType) => new NamedObjectType.IdentifierProperty({
                 identifierMintingStrategy: astType.identifierMintingStrategy,
                 identifierPrefixPropertyName: `${syntheticNamePrefix}identifierPrefix`,
                 name: `${syntheticNamePrefix}identifier`,
-                objectType,
+                namedObjectType,
                 type: identifierType,
                 typeAlias: code `${staticModuleName}.${syntheticNamePrefix}Identifier`,
                 visibility: "public",
             }),
-            lazyParentObjectTypes: () => astType.parentObjectTypes.map((astType) => this.createObjectType(astType)),
-            lazyProperties: (objectType) => {
+            lazyParentObjectTypes: () => astType.parentObjectTypes.map((astType) => this.createNamedObjectType(astType)),
+            lazyProperties: (namedObjectType) => {
                 const properties = astType.properties
                     .toSorted((left, right) => {
                     if (left.order < right.order) {
@@ -130,18 +130,18 @@ export class TypeFactory {
                 })
                     .map((astProperty) => this.createObjectTypeProperty({
                     astObjectTypeProperty: astProperty,
-                    objectType,
+                    namedObjectType,
                 }));
-                if (objectType._discriminantProperty.type.ownValues.length > 0 ||
-                    objectType._discriminantProperty.type.descendantValues.length > 0) {
-                    properties.splice(0, 0, objectType._discriminantProperty);
+                if (namedObjectType._discriminantProperty.type.ownValues.length > 0 ||
+                    namedObjectType._discriminantProperty.type.descendantValues.length > 0) {
+                    properties.splice(0, 0, namedObjectType._discriminantProperty);
                 }
                 // Some ObjectTypes have an identifierPrefix property, depending on their identifier minting strategy.
-                if (objectTypeNeedsIdentifierPrefixProperty(astType)) {
-                    properties.splice(0, 0, new ObjectType.IdentifierPrefixProperty({
+                if (namedObjectTypeNeedsIdentifierPrefixProperty(astType)) {
+                    properties.splice(0, 0, new NamedObjectType.IdentifierPrefixProperty({
                         name: `${syntheticNamePrefix}identifierPrefix`,
-                        objectType,
-                        own: !astType.ancestorObjectTypes.some(objectTypeNeedsIdentifierPrefixProperty),
+                        namedObjectType,
+                        own: !astType.ancestorObjectTypes.some(namedObjectTypeNeedsIdentifierPrefixProperty),
                         type: new StringType({
                             comment: astType.comment,
                             datatype: xsd.string,
@@ -154,8 +154,8 @@ export class TypeFactory {
                         visibility: "protected",
                     }));
                 }
-                // Every ObjectType has an identifier property. Some are abstract.
-                properties.splice(0, 0, objectType.identifierProperty);
+                // Every NamedObjectType has an identifier property. Some are abstract.
+                properties.splice(0, 0, namedObjectType.identifierProperty);
                 return properties;
             },
             name,
@@ -164,8 +164,8 @@ export class TypeFactory {
             synthetic: astType.synthetic,
             toRdfTypes: astType.toRdfTypes,
         });
-        this.cachedObjectTypesByShapeIdentifier.set(astType.shapeIdentifier, objectType);
-        return objectType;
+        this.cachedObjectTypesByShapeIdentifier.set(astType.shapeIdentifier, namedObjectType);
+        return namedObjectType;
     }
     createType(astType, parameters) {
         switch (astType.kind) {
@@ -190,7 +190,7 @@ export class TypeFactory {
             case "LiteralType":
                 return this.createLiteralType(astType, parameters);
             case "ObjectType":
-                return this.createObjectType(astType);
+                return this.createNamedObjectType(astType);
             case "OptionType":
                 return this.createOptionType(astType);
             case "SetType":
@@ -419,19 +419,19 @@ export class TypeFactory {
             languageIn: astType.languageIn,
         });
     }
-    createObjectTypeProperty({ astObjectTypeProperty, objectType, }) {
+    createObjectTypeProperty({ astObjectTypeProperty, namedObjectType, }) {
         {
             const cachedProperty = this.cachedObjectTypePropertiesByShapeIdentifier.get(astObjectTypeProperty.shapeIdentifier);
             if (cachedProperty) {
                 return cachedProperty;
             }
         }
-        const property = new ObjectType.ShaclProperty({
+        const property = new NamedObjectType.ShaclProperty({
             comment: astObjectTypeProperty.comment,
             description: astObjectTypeProperty.description,
             label: astObjectTypeProperty.label,
             mutable: astObjectTypeProperty.mutable,
-            objectType,
+            namedObjectType,
             name: tsName(astObjectTypeProperty.name),
             path: astObjectTypeProperty.path,
             recursive: !!astObjectTypeProperty.recursive,
@@ -471,8 +471,8 @@ export class TypeFactory {
         });
     }
 }
-function objectTypeNeedsIdentifierPrefixProperty(objectType) {
-    return objectType.identifierMintingStrategy
+function namedObjectTypeNeedsIdentifierPrefixProperty(namedObjectType) {
+    return namedObjectType.identifierMintingStrategy
         .map((identifierMintingStrategy) => {
         switch (identifierMintingStrategy) {
             case "blankNode":

package/dist/generators/ts/ZodGenerator.js

@@ -1,31 +1,33 @@
 import { invariant } from "ts-invariant";
 import * as ast from "../../ast/index.js";
-import { ObjectType_jsonTypeAliasDeclaration } from "./_ObjectType/ObjectType_jsonTypeAliasDeclaration.js";
-import { ObjectType_jsonZodSchemaFunctionDeclaration } from "./_ObjectType/ObjectType_jsonZodSchemaFunctionDeclaration.js";
+import { NamedObjectType_jsonSchemaFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_jsonSchemaFunctionDeclaration.js";
+import { NamedObjectType_jsonTypeAliasDeclaration } from "./_NamedObjectType/NamedObjectType_jsonTypeAliasDeclaration.js";
 import { snippets } from "./snippets.js";
+import { syntheticNamePrefix } from "./syntheticNamePrefix.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))) {
+        for (const namedObjectType of ast.ObjectType.toposort(ast_.namedObjectTypes).map((astObjectType) => this.typeFactory.createNamedObjectType(astObjectType))) {
             declarations.push(code `\
-export namespace ${objectType.staticModuleName} {
-${joinCode([
-                ...ObjectType_jsonTypeAliasDeclaration.bind(objectType)().toList(),
-                ...ObjectType_jsonZodSchemaFunctionDeclaration.bind(objectType)().toList(),
-            ], { on: "\n\n" })}
+export namespace ${namedObjectType.staticModuleName} {
+  ${joinCode(NamedObjectType_jsonTypeAliasDeclaration.bind(namedObjectType)().toList())}
+
+  export namespace ${syntheticNamePrefix}Json {
+    ${joinCode(NamedObjectType_jsonSchemaFunctionDeclaration.bind(namedObjectType)().toList())}
+  }
 }`);
         }
         for (const astNamedUnionType of ast_.namedUnionTypes.map((astNamedUnionType) => this.typeFactory.createUnionType(astNamedUnionType))) {
             invariant(astNamedUnionType.kind !== "AnonymousUnionType");
             declarations.push(code `\
 export namespace ${astNamedUnionType.staticModuleName} {
-${joinCode([
-                astNamedUnionType.jsonTypeAliasDeclaration,
-                astNamedUnionType.jsonZodSchemaFunctionDeclaration,
-            ], { on: "\n\n" })}
+  ${astNamedUnionType.jsonTypeAliasDeclaration}
+  export namespace ${syntheticNamePrefix}Json {
+    ${astNamedUnionType.jsonSchemaFunctionDeclaration}
+  }
 }`);
         }
         declarations.splice(0, 0, joinCode(Object.values(snippets)

package/dist/generators/ts/{_ObjectType → _NamedObjectType}/AbstractProperty.d.ts

@@ -1,10 +1,10 @@
 import type { Maybe } from "purify-ts";
 import type { PropertyVisibility } from "../../../enums/PropertyVisibility.js";
-import type { ObjectType } from "../ObjectType.js";
+import type { NamedObjectType } from "../NamedObjectType.js";
 import type { Type } from "../Type.js";
 import { type Code } from "../ts-poet-wrapper.js";
 export declare abstract class AbstractProperty<TypeT extends Pick<Type, "filterFunction" | "mutable" | "name" | "schema">> {
-    protected readonly objectType: ObjectType;
+    protected readonly namedObjectType: NamedObjectType;
     /**
      * Optional property to include in the parameters object of a class constructor.
      */
@@ -47,7 +47,7 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "filterF
     /**
      * zod Object key: schema pair on the property serialized by toJsonObjectMember.
      */
-    abstract readonly jsonZodSchema: Maybe<{
+    abstract readonly jsonZchema: Maybe<{
         readonly key: string;
         readonly schema: Code;
     }>;
@@ -64,7 +64,7 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "filterF
      */
     readonly name: string;
     /**
-     * Is the property's type the ObjectType or does its type indirectly reference the ObjectType?
+     * Is the property's type the NamedObjectType or does its type indirectly reference the NamedObjectType?
      */
     abstract readonly recursive: boolean;
     /**
@@ -75,9 +75,9 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "filterF
      * Property visibility: private, protected, public.
      */
     readonly visibility: PropertyVisibility;
-    constructor({ name, objectType, type, visibility, }: {
+    constructor({ name, namedObjectType, type, visibility, }: {
         name: string;
-        objectType: ObjectType;
+        namedObjectType: NamedObjectType;
         type: TypeT;
         visibility: PropertyVisibility;
     });

package/dist/generators/ts/{_ObjectType → _NamedObjectType}/AbstractProperty.js

@@ -9,7 +9,7 @@ import { Memoize } from "typescript-memoize";
 import { removeUndefined } from "../removeUndefined.js";
 import { code, literalOf } from "../ts-poet-wrapper.js";
 export class AbstractProperty {
-    objectType;
+    namedObjectType;
     /**
      * TypeScript identifier-safe name of the property.
      */
@@ -22,9 +22,9 @@ export class AbstractProperty {
      * Property visibility: private, protected, public.
      */
     visibility;
-    constructor({ name, objectType, type, visibility, }) {
+    constructor({ name, namedObjectType, type, visibility, }) {
         this.name = name;
-        this.objectType = objectType;
+        this.namedObjectType = namedObjectType;
         this.type = type;
         this.visibility = visibility;
     }

package/dist/generators/ts/{_ObjectType → _NamedObjectType}/DiscriminantProperty.d.ts

@@ -15,7 +15,7 @@ export declare class DiscriminantProperty extends AbstractProperty<DiscriminantP
     } & ConstructorParameters<typeof AbstractProperty>[0]);
     get declaration(): Maybe<Code>;
     get jsonSignature(): Maybe<Code>;
-    get jsonZodSchema(): AbstractProperty<DiscriminantProperty.Type>["jsonZodSchema"];
+    get jsonZchema(): AbstractProperty<DiscriminantProperty.Type>["jsonZchema"];
     private get abstract();
     private get initializer();
     private get override();

package/dist/generators/ts/{_ObjectType → _NamedObjectType}/DiscriminantProperty.js

@@ -26,20 +26,20 @@ export class DiscriminantProperty extends AbstractProperty {
         invariant(this.visibility === "public");
     }
     get declaration() {
-        switch (this.objectType.declarationType) {
+        switch (this.namedObjectType.declarationType) {
             case "class":
                 return Maybe.of(code `${this.abstract ? "abstract " : ""}${this.override ? "override " : ""}readonly ${this.name}: ${this.type.name}${!this.abstract ? code ` = ${this.initializer};` : ";"}`);
             case "interface":
                 return Maybe.of(code `readonly ${this.name}: ${this.type.name};`);
             default:
-                this.objectType.declarationType;
+                this.namedObjectType.declarationType;
                 throw new Error("should never reach this point");
         }
     }
     get jsonSignature() {
         return Maybe.of(code `readonly ${this.name}: ${this.type.name}`);
     }
-    get jsonZodSchema() {
+    get jsonZchema() {
         return Maybe.of({
             key: this.name,
             schema: this.type.values.length > 1
@@ -48,16 +48,16 @@ export class DiscriminantProperty extends AbstractProperty {
         });
     }
     get abstract() {
-        return this.objectType.abstract;
+        return this.namedObjectType.abstract;
     }
     get initializer() {
-        return code `${literalOf(this.objectType.discriminantValue)} as const`;
+        return code `${literalOf(this.namedObjectType.discriminantValue)} as const`;
     }
     get override() {
-        return this.objectType.parentObjectTypes.length > 0;
+        return this.namedObjectType.parentObjectTypes.length > 0;
     }
     constructorStatements() {
-        switch (this.objectType.declarationType) {
+        switch (this.namedObjectType.declarationType) {
             case "class":
                 return [];
             case "interface":
@@ -68,13 +68,15 @@ export class DiscriminantProperty extends AbstractProperty {
         }
     }
     fromJsonStatements() {
-        return !this.abstract && this.objectType.declarationType === "interface"
+        return !this.abstract &&
+            this.namedObjectType.declarationType === "interface"
             ? [code `const ${this.name} = ${this.initializer};`]
             : [];
     }
     fromRdfResourceValuesExpression() {
-        return !this.abstract && this.objectType.declarationType === "interface"
-            ? Maybe.of(code `${imports.Right}<${literalOf(this.objectType.discriminantValue)}>(${this.initializer})`)
+        return !this.abstract &&
+            this.namedObjectType.declarationType === "interface"
+            ? Maybe.of(code `${imports.Right}<${literalOf(this.namedObjectType.discriminantValue)}>(${this.initializer})`)
             : Maybe.empty();
     }
     hashStatements({ variables, }) {
@@ -102,7 +104,7 @@ __decorate([
 ], DiscriminantProperty.prototype, "jsonSignature", null);
 __decorate([
     Memoize()
-], DiscriminantProperty.prototype, "jsonZodSchema", null);
+], DiscriminantProperty.prototype, "jsonZchema", null);
 (function (DiscriminantProperty) {
     class Type {
         filterFunction = code `nonextant`;

package/dist/generators/ts/{_ObjectType → _NamedObjectType}/IdentifierPrefixProperty.d.ts

@@ -7,7 +7,7 @@ export declare class IdentifierPrefixProperty extends AbstractProperty<StringTyp
     readonly filterProperty: AbstractProperty<StringType>["filterProperty"];
     readonly graphqlField: AbstractProperty<StringType>["graphqlField"];
     readonly jsonSignature: Maybe<Code>;
-    readonly jsonZodSchema: AbstractProperty<StringType>["jsonZodSchema"];
+    readonly jsonZchema: AbstractProperty<StringType>["jsonZchema"];
     readonly kind = "IdentifierPrefixProperty";
     readonly mutable = false;
     readonly recursive = false;

package/dist/generators/ts/{_ObjectType → _NamedObjectType}/IdentifierPrefixProperty.js

@@ -16,7 +16,7 @@ export class IdentifierPrefixProperty extends AbstractProperty {
     filterProperty = Maybe.empty();
     graphqlField = Maybe.empty();
     jsonSignature = Maybe.empty();
-    jsonZodSchema = Maybe.empty();
+    jsonZchema = Maybe.empty();
     kind = "IdentifierPrefixProperty";
     mutable = false;
     recursive = false;
@@ -29,7 +29,7 @@ export class IdentifierPrefixProperty extends AbstractProperty {
         return Maybe.of(code `readonly ${this.name}?: ${this.type.name};`);
     }
     get declaration() {
-        if (this.objectType.declarationType === "interface") {
+        if (this.namedObjectType.declarationType === "interface") {
             return Maybe.empty();
         }
         if (!this.own) {
@@ -38,7 +38,7 @@ export class IdentifierPrefixProperty extends AbstractProperty {
         return Maybe.of(code `protected readonly _${this.name}?: ${this.type.name};`);
     }
     get equalsFunction() {
-        return this.objectType.declarationType === "class"
+        return this.namedObjectType.declarationType === "class"
             ? Maybe.of(code `${snippets.strictEquals}`)
             : Maybe.empty();
     }
@@ -49,7 +49,7 @@ protected ${!this.own ? "override " : ""} get ${this.name}(): ${this.type.name}
 }`);
     }
     constructorStatements({ variables, }) {
-        switch (this.objectType.declarationType) {
+        switch (this.namedObjectType.declarationType) {
             case "class":
                 return this.declaration
                     .map(() => [code `this._${this.name} = ${variables.parameter};`])

package/dist/generators/ts/{_ObjectType → _NamedObjectType}/IdentifierProperty.d.ts

@@ -28,7 +28,7 @@ export declare class IdentifierProperty extends AbstractProperty<BlankNodeType |
     get getAccessorDeclaration(): Maybe<Code>;
     get graphqlField(): AbstractProperty<IdentifierType>["graphqlField"];
     get jsonSignature(): Maybe<Code>;
-    get jsonZodSchema(): AbstractProperty<IdentifierType>["jsonZodSchema"];
+    get jsonZchema(): AbstractProperty<IdentifierType>["jsonZchema"];
     private get abstract();
     private get declarationModifiers();
     private get declarationName();