@shaclmate/compiler 4.0.9 → 4.0.10

package/dist/ShapesGraphToAstTransformer.js

@@ -74,7 +74,7 @@ export class ShapesGraphToAstTransformer {
         }
         return Either.of({
             namedIntersectionTypes: astNamedIntersectionTypes,
-            objectTypes: astObjectTypes.concat(Object.values(syntheticAstObjectTypesByName)),
+            namedObjectTypes: astObjectTypes.concat(Object.values(syntheticAstObjectTypesByName)),
             namedUnionTypes: astNamedUnionTypes,
         });
     }

package/dist/ast/Ast.d.ts

@@ -3,7 +3,7 @@ import type { ObjectType } from "./ObjectType.js";
 import type { UnionType } from "./UnionType.js";
 export interface Ast {
     readonly namedIntersectionTypes: readonly IntersectionType[];
+    readonly namedObjectTypes: readonly ObjectType[];
     readonly namedUnionTypes: readonly UnionType[];
-    readonly objectTypes: readonly ObjectType[];
 }
 //# sourceMappingURL=Ast.d.ts.map

package/dist/generators/json/AstJsonGenerator.js

@@ -116,7 +116,7 @@ function typeToJson(type) {
 export class AstJsonGenerator {
     generate(ast) {
         return JSON.stringify({
-            objectTypes: ast.objectTypes.map((objectType) => ({
+            objectTypes: ast.namedObjectTypes.map((objectType) => ({
                 kind: objectType.kind,
                 comment: objectType.comment.extract(),
                 identifierMintingStrategy: objectType.identifierMintingStrategy.extract(),

package/dist/generators/ts/AbstractCollectionType.d.ts

@@ -31,7 +31,7 @@ export declare abstract class AbstractCollectionType<ItemTypeT extends AbstractC
     graphqlResolveExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["graphqlResolveExpression"]>[0]): Code;
     hashStatements({ depth, variables, }: Parameters<AbstractContainerType<ItemTypeT>["hashStatements"]>[0]): readonly Code[];
     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;
 }
 export declare namespace AbstractCollectionType {

package/dist/generators/ts/AbstractCollectionType.js

@@ -190,8 +190,8 @@ export class AbstractCollectionType extends AbstractContainerType {
     jsonUiSchemaElement(parameters) {
         return this.itemType.jsonUiSchemaElement(parameters);
     }
-    jsonZodSchema(parameters) {
-        let schema = code `${this.itemType.jsonZodSchema(parameters)}.array()`;
+    jsonSchema(parameters) {
+        let schema = code `${this.itemType.jsonSchema(parameters)}.array()`;
         if (this.minCount > 0) {
             schema = code `${schema}.nonempty().min(${this.minCount})`;
         }

package/dist/generators/ts/AbstractContainerType.d.ts

@@ -13,9 +13,9 @@ import type { IntType } from "./IntType.js";
 import type { IriType } from "./IriType.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 { StringType } from "./StringType.js";
 import type { TermType } from "./TermType.js";
 import type { Type } from "./Type.js";
@@ -48,7 +48,7 @@ export declare namespace AbstractContainerType {
     type DiscriminantProperty = AbstractType.DiscriminantProperty;
     const GraphqlType: typeof AbstractType.GraphqlType;
     type GraphqlType = AbstractType.GraphqlType;
-    type ItemType = AnonymousUnionType | BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | FloatType | IdentifierType | IntType | IriType | ListType<ListType.ItemType> | LiteralType | NamedObjectUnionType | NamedUnionType | ObjectType | StringType | TermType;
+    type ItemType = AnonymousUnionType | BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | FloatType | IdentifierType | IntType | IriType | ListType<ListType.ItemType> | LiteralType | NamedObjectUnionType | NamedUnionType | NamedObjectType | StringType | TermType;
     function isItemType(type: Type): type is ItemType;
     const JsonType: typeof AbstractType.JsonType;
     type JsonType = AbstractType.JsonType;

package/dist/generators/ts/AbstractContainerType.js

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

package/dist/generators/ts/AbstractLazyObjectType.d.ts

@@ -1,7 +1,7 @@
 import { Maybe, NonEmptyList } from "purify-ts";
 import { AbstractType } from "./AbstractType.js";
+import type { NamedObjectType } from "./NamedObjectType.js";
 import type { NamedObjectUnionType } from "./NamedObjectUnionType.js";
-import type { ObjectType } from "./ObjectType.js";
 import type { OptionType } from "./OptionType.js";
 import type { SetType } from "./SetType.js";
 import { type Code } from "./ts-poet-wrapper.js";
@@ -41,7 +41,7 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
     hashStatements({ depth, variables, }: Parameters<AbstractType["hashStatements"]>[0]): readonly Code[];
     jsonType(parameters?: Parameters<AbstractType["jsonType"]>[0]): AbstractType.JsonType;
     jsonUiSchemaElement(parameters: Parameters<AbstractType["jsonUiSchemaElement"]>[0]): Maybe<Code>;
-    jsonZodSchema(parameters: Parameters<AbstractType["jsonZodSchema"]>[0]): Code;
+    jsonSchema(parameters: Parameters<AbstractType["jsonSchema"]>[0]): Code;
     toJsonExpression({ variables, }: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
     protected resolvedNamedObjectUnionTypeToPartialNamedObjectUnionTypeConversion({ resolvedNamedObjectUnionType, partialNamedObjectUnionType, variables, }: {
@@ -53,7 +53,7 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
     }): Code;
 }
 export declare namespace AbstractLazyObjectType {
-    type ObjectTypeConstraint = ObjectType | NamedObjectUnionType;
+    type ObjectTypeConstraint = NamedObjectType | NamedObjectUnionType;
     type PartialTypeConstraint = ObjectTypeConstraint | OptionType<ObjectTypeConstraint> | SetType<ObjectTypeConstraint>;
     type ResolveTypeConstraint = PartialTypeConstraint;
     type Conversion = AbstractType.Conversion;

package/dist/generators/ts/AbstractLazyObjectType.js

@@ -92,8 +92,8 @@ export class AbstractLazyObjectType extends AbstractType {
     jsonUiSchemaElement(parameters) {
         return this.partialType.jsonUiSchemaElement(parameters);
     }
-    jsonZodSchema(parameters) {
-        return this.partialType.jsonZodSchema(parameters);
+    jsonSchema(parameters) {
+        return this.partialType.jsonSchema(parameters);
     }
     toJsonExpression({ variables, }) {
         return this.partialType.toJsonExpression({

package/dist/generators/ts/AbstractNamedUnionType.d.ts

@@ -16,7 +16,7 @@ export declare abstract class AbstractNamedUnionType<MemberTypeT extends Type> e
     get filterFunction(): Code;
     get filterType(): Code;
     get jsonTypeAliasDeclaration(): Code;
-    get jsonZodSchemaFunctionDeclaration(): Code;
+    get jsonSchemaFunctionDeclaration(): Code;
     get name(): string;
     get staticModuleName(): string;
     get valueSparqlConstructTriplesFunction(): Code;
@@ -26,7 +26,7 @@ export declare abstract class AbstractNamedUnionType<MemberTypeT extends Type> e
     fromRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["fromRdfResourceValuesExpression"]>[0]): Code;
     hashStatements({ depth, variables, }: Parameters<AbstractType["hashStatements"]>[0]): readonly Code[];
     jsonType(): AbstractType.JsonType;
-    jsonZodSchema({ context, }: Parameters<AbstractType["jsonZodSchema"]>[0]): Code;
+    jsonSchema({ context, }: Parameters<AbstractType["jsonSchema"]>[0]): Code;
     toJsonExpression({ variables, }: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
 }

package/dist/generators/ts/AbstractNamedUnionType.js

@@ -50,8 +50,8 @@ ${joinCode(staticModuleDeclarations
     get jsonTypeAliasDeclaration() {
         return code `export type ${syntheticNamePrefix}Json = ${this.inlineJsonType.name}`;
     }
-    get jsonZodSchemaFunctionDeclaration() {
-        return code `export const ${syntheticNamePrefix}jsonZodSchema = () => ${this.inlineJsonZodSchema};`;
+    get jsonSchemaFunctionDeclaration() {
+        return code `export const schema = () => ${this.inlineJsonSchema};`;
     }
     get name() {
         return this._name;
@@ -86,18 +86,20 @@ ${joinCode(staticModuleDeclarations
                 code `export function ${syntheticNamePrefix}hash<HasherT extends ${snippets.Hasher}>(value: ${this._name}, hasher: HasherT): HasherT { ${this.inlineHashStatements({ depth: 0, variables: { hasher: code `hasher`, value: code `value` } })} return hasher; }`;
         }
         if (this.features.has("json")) {
-            staticModuleDeclarations[`${syntheticNamePrefix}Json`] =
-                this.jsonTypeAliasDeclaration;
+            staticModuleDeclarations[`${syntheticNamePrefix}Json`] = code `\
+${this.jsonTypeAliasDeclaration}
+
+export namespace ${syntheticNamePrefix}Json {
+  ${this.jsonSchemaFunctionDeclaration}
+
+  export function ${syntheticNamePrefix}parse(json: unknown): ${imports.Either}<Error, ${syntheticNamePrefix}Json> {
+    const jsonSafeParseResult = schema().safeParse(json);
+    if (!jsonSafeParseResult.success) { return ${imports.Left}(jsonSafeParseResult.error); }
+    return ${imports.Right}(jsonSafeParseResult.data);
+  }
+}`;
             staticModuleDeclarations[`${syntheticNamePrefix}fromJson`] =
                 code `export const ${syntheticNamePrefix}fromJson = ${this.inlineFromJsonFunction};`;
-            staticModuleDeclarations[`${syntheticNamePrefix}jsonZodSchema`] =
-                this.jsonZodSchemaFunctionDeclaration;
-            staticModuleDeclarations[`${syntheticNamePrefix}parseJson`] = code `\
-export function ${syntheticNamePrefix}parseJson(json: unknown): ${imports.Either}<Error, ${this.name}> {
-  const ${syntheticNamePrefix}jsonSafeParseResult = ${syntheticNamePrefix}jsonZodSchema().safeParse(json);
-  if (!${syntheticNamePrefix}jsonSafeParseResult.success) { return ${imports.Left}(${syntheticNamePrefix}jsonSafeParseResult.error); }
-  return ${imports.Right}(${syntheticNamePrefix}fromJson(${syntheticNamePrefix}jsonSafeParseResult.data));
-}`;
             staticModuleDeclarations[`${syntheticNamePrefix}toJson`] =
                 code `export const ${syntheticNamePrefix}toJson = ${this.inlineToJsonFunction};`;
         }
@@ -142,15 +144,15 @@ export function ${syntheticNamePrefix}parseJson(json: unknown): ${imports.Either
         }
         return this.inlineJsonType;
     }
-    jsonZodSchema({ context, }) {
+    jsonSchema({ context, }) {
         if (this.features.has("json")) {
-            const expression = code `${this.staticModuleName}.${syntheticNamePrefix}jsonZodSchema()`;
+            const expression = code `${this.staticModuleName}.${syntheticNamePrefix}Json.schema()`;
             if (context === "property" && this.recursive) {
                 return code `${imports.z}.lazy((): ${imports.z}.ZodType<${this.staticModuleName}.${syntheticNamePrefix}Json> => ${expression})`;
             }
             return expression;
         }
-        return this.inlineJsonZodSchema;
+        return this.inlineJsonSchema;
     }
     toJsonExpression({ variables, }) {
         if (this.features.has("json")) {

package/dist/generators/ts/AbstractNumericType.d.ts

@@ -15,7 +15,7 @@ export declare abstract class AbstractNumericType<ValueT extends bigint | number
         languageIn: import("ts-poet/build/Node.js").Node[] | undefined;
         kind: Code;
     };
-    jsonZodSchema(_parameters: Parameters<AbstractPrimitiveType<ValueT>["jsonZodSchema"]>[0]): Code;
+    jsonSchema(_parameters: Parameters<AbstractPrimitiveType<ValueT>["jsonSchema"]>[0]): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<string>["toRdfResourceValuesExpression"]>[0]): Code;
     protected fromRdfExpressionChain({ variables, }: Parameters<AbstractPrimitiveType<ValueT>["fromRdfExpressionChain"]>[0]): ReturnType<AbstractPrimitiveType<ValueT>["fromRdfExpressionChain"]>;
     protected abstract fromRdfResourceValueExpression(variables: {

package/dist/generators/ts/AbstractNumericType.js

@@ -40,7 +40,7 @@ export class AbstractNumericType extends AbstractPrimitiveType {
                 : undefined,
         };
     }
-    jsonZodSchema(_parameters) {
+    jsonSchema(_parameters) {
         switch (this.primitiveIn.length) {
             case 0:
                 return code `${imports.z}.${this.typeofs[0]}()`;

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

@@ -127,7 +127,7 @@ export declare abstract class AbstractType {
      * An expression that converts a Either<Error, rdfjsResource.Resource.Values> to a
      * Either<Error, rdfjsResource.Resource.Values<this type>>.
      *
-     * These expressions are used to deserialize property values in an ObjectType, either directly (a property with this Type) or indirectly (a property with a Type like OptionType
+     * These expressions are used to deserialize property values in an NamedObjectType, either directly (a property with this Type) or indirectly (a property with a Type like OptionType
      * that has a type parameter of this Type).
      *
      * Some types need to filter on the set of all objects/values of a (subject, predicate). For example, all sh:hasValue values must be present in the set for any values
@@ -136,7 +136,7 @@ export declare abstract class AbstractType {
      * Values may also need to be sorted. For example, specifying preferredLanguages should sort the values in the order of the specified languages so that the first value
      * (if it exists) is always of the first preferred language.
      *
-     * variables are runtime variables, most derived from the parameters of the ObjectType's fromRdf function:
+     * variables are runtime variables, most derived from the parameters of the NamedObjectType's fromRdf function:
      *   context: unanticipated properties (...) passed to Object.fromRdf
      *   graph: DefaultGraph | NamedNode | undefined to match (subject, predicate, object) triples in; if undefined, match triples in all graphs
      *   ignoreRdfType: whether the RDF type of objects/object unions should be ignored
@@ -195,12 +195,12 @@ export declare abstract class AbstractType {
      * Zod schema for the JSON type of this type.
      *
      * This method is called in two contexts:
-     * "property": from a ShaclProperty, while generating the z.object properties of an ObjectType
+     * "property": from a ShaclProperty, while generating the z.object properties of an NamedObjectType
      * "type": from another Type e.g., an OptionType or UnionType
      *
      * z.lazy() should only be returned for "property".
      */
-    abstract jsonZodSchema(parameters: {
+    abstract jsonSchema(parameters: {
         includeDiscriminantProperty?: boolean;
         context: "property" | "type";
     }): Code;
@@ -218,7 +218,7 @@ export declare abstract class AbstractType {
      * An expression that converts a property value of this type to a value or an array of values that can be .add'd to a Resource with
      *   resource.add(predicate, convertedValue, graph)
      *
-     * variables are runtime variables, most derived from the parameters of the ObjectType's fromRdf function:
+     * variables are runtime variables, most derived from the parameters of the NamedObjectType's fromRdf function:
      *   graph: DefaultGraph | NamedNode | undefined to .add to; if undefined, add to the default graph
      *   propertyPath: predicate path (NamedNode) or InversePath on a predicate path
      *   resource: the Resource to .add to

package/dist/generators/ts/AbstractUnionType.d.ts

@@ -32,7 +32,7 @@ export declare abstract class AbstractUnionType<MemberTypeT extends Type> extend
     protected get inlineFromJsonFunction(): Code;
     protected get inlineFromRdfResourceValuesFunction(): Code;
     protected get inlineJsonType(): AbstractType.JsonType;
-    protected get inlineJsonZodSchema(): Code;
+    protected get inlineJsonSchema(): Code;
     protected get inlineName(): Code;
     protected get inlineValueSparqlConstructTriplesFunction(): Code;
     protected get inlineValueSparqlWherePatternsFunction(): Code;

package/dist/generators/ts/AbstractUnionType.js

@@ -87,7 +87,7 @@ export class AbstractUnionType extends AbstractType {
                             switch (member.type.kind) {
                                 case "NamedObjectUnionType":
                                 case "NamedUnionType":
-                                case "ObjectType":
+                                case "NamedObjectType":
                                     return code `${member.type.staticModuleName}.is${member.type.name}(${instance})`;
                             }
                         }
@@ -288,17 +288,17 @@ ${joinCode(this.concreteMembers.map(({ jsonTypeCheck, type, unwrap, wrap }) => c
                 throw this.discriminant;
         }
     }
-    get inlineJsonZodSchema() {
+    get inlineJsonSchema() {
         switch (this.discriminant.kind) {
             case "envelope":
-                return code `${imports.z}.discriminatedUnion("${this.discriminant.name}", [${joinCode(this.concreteMembers.map(({ type, primaryDiscriminantValue }) => code `${imports.z}.object({ ${this.discriminant.name}: ${imports.z}.literal(${literalOf(primaryDiscriminantValue)}), value: ${type.jsonZodSchema({ context: "type" })} })`), { on: "," })}])`;
+                return code `${imports.z}.discriminatedUnion("${this.discriminant.name}", [${joinCode(this.concreteMembers.map(({ type, primaryDiscriminantValue }) => code `${imports.z}.object({ ${this.discriminant.name}: ${imports.z}.literal(${literalOf(primaryDiscriminantValue)}), value: ${type.jsonSchema({ context: "type" })} })`), { on: "," })}])`;
             case "inline":
-                return code `${imports.z}.discriminatedUnion("${this.discriminant.name}", [${joinCode(this.concreteMembers.map(({ type }) => type.jsonZodSchema({
+                return code `${imports.z}.discriminatedUnion("${this.discriminant.name}", [${joinCode(this.concreteMembers.map(({ type }) => type.jsonSchema({
                     includeDiscriminantProperty: true,
                     context: "type",
                 })), { on: "," })}])`;
             case "typeof":
-                return code `${imports.z}.union([${joinCode(this.concreteMembers.map(({ type }) => type.jsonZodSchema({ context: "type" })), { on: "," })}])`;
+                return code `${imports.z}.union([${joinCode(this.concreteMembers.map(({ type }) => type.jsonSchema({ context: "type" })), { on: "," })}])`;
             default:
                 throw this.discriminant;
         }
@@ -308,7 +308,7 @@ ${joinCode(this.concreteMembers.map(({ jsonTypeCheck, type, unwrap, wrap }) => c
             case "envelope":
                 return code `(${joinCode(this.concreteMembers.map(({ type, primaryDiscriminantValue }) => code `{ ${this.discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${type.name} }`), { on: "|" })})`;
             case "inline":
-                // If every type shares a discriminant (e.g., RDF/JS "termType" or generated ObjectType "type"),
+                // If every type shares a discriminant (e.g., RDF/JS "termType" or generated NamedObjectType "type"),
                 // just join their names with "|"
                 return code `(${joinCode(this.members.map(({ type }) => code `${type.name}`), { on: "|" })})`;
             case "typeof":

package/dist/generators/ts/AnonymousUnionType.d.ts

@@ -19,7 +19,7 @@ export declare class AnonymousUnionType extends AbstractUnionType<Type> {
     graphqlResolveExpression(_parameters: Parameters<AbstractType["graphqlResolveExpression"]>[0]): Code;
     hashStatements(parameters: Parameters<AbstractType["hashStatements"]>[0]): readonly Code[];
     jsonType(): AbstractType.JsonType;
-    jsonZodSchema(_parameters: Parameters<AbstractType["jsonZodSchema"]>[0]): Code;
+    jsonSchema(_parameters: Parameters<AbstractType["jsonSchema"]>[0]): Code;
     toJsonExpression({ variables, }: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
 }

package/dist/generators/ts/AnonymousUnionType.js

@@ -42,8 +42,8 @@ export class AnonymousUnionType extends AbstractUnionType {
     jsonType() {
         return this.inlineJsonType;
     }
-    jsonZodSchema(_parameters) {
-        return this.inlineJsonZodSchema;
+    jsonSchema(_parameters) {
+        return this.inlineJsonSchema;
     }
     toJsonExpression({ variables, }) {
         return code `${this.inlineToJsonFunction}(${variables.value})`;

package/dist/generators/ts/BigDecimalType.d.ts

@@ -13,7 +13,7 @@ export declare class BigDecimalType extends AbstractLiteralType {
     graphqlResolveExpression({ variables, }: Parameters<AbstractLiteralType["graphqlResolveExpression"]>[0]): Code;
     hashStatements({ variables, }: Parameters<AbstractLiteralType["hashStatements"]>[0]): readonly Code[];
     jsonType(): AbstractLiteralType.JsonType;
-    jsonZodSchema(): Code;
+    jsonSchema(): Code;
     toJsonExpression({ variables, }: Parameters<AbstractLiteralType["toJsonExpression"]>[0]): Code;
     protected fromRdfExpressionChain({ variables, }: Parameters<AbstractLiteralType["fromRdfExpressionChain"]>[0]): ReturnType<AbstractLiteralType["fromRdfExpressionChain"]>;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractLiteralType["toRdfResourceValuesExpression"]>[0]): Code;

package/dist/generators/ts/BigDecimalType.js

@@ -63,7 +63,7 @@ export class BigDecimalType extends AbstractLiteralType {
     jsonType() {
         return new AbstractLiteralType.JsonType("string");
     }
-    jsonZodSchema() {
+    jsonSchema() {
         return code `${imports.z}.string()`;
     }
     toJsonExpression({ variables, }) {
@@ -87,5 +87,5 @@ __decorate([
 ], BigDecimalType.prototype, "jsonType", null);
 __decorate([
     Memoize()
-], BigDecimalType.prototype, "jsonZodSchema", null);
+], BigDecimalType.prototype, "jsonSchema", null);
 //# sourceMappingURL=BigDecimalType.js.map

package/dist/generators/ts/BigIntType.d.ts

@@ -6,7 +6,7 @@ export declare class BigIntType extends AbstractNumericType<bigint> {
     readonly kind = "BigIntType";
     readonly typeofs: NonEmptyList<"bigint">;
     fromJsonExpression({ variables, }: Parameters<AbstractNumericType<bigint>["fromJsonExpression"]>[0]): Code;
-    jsonZodSchema(_parameters: Parameters<AbstractNumericType<bigint>["jsonZodSchema"]>[0]): Code;
+    jsonSchema(_parameters: Parameters<AbstractNumericType<bigint>["jsonSchema"]>[0]): Code;
     jsonType(): AbstractNumericType.JsonType;
     toJsonExpression({ variables, }: Parameters<AbstractNumericType<bigint>["toJsonExpression"]>[0]): Code;
     protected fromRdfResourceValueExpression({ variables, }: Parameters<AbstractNumericType<bigint>["fromRdfResourceValueExpression"]>[0]): Code;

package/dist/generators/ts/BigIntType.js

@@ -20,7 +20,7 @@ export class BigIntType extends AbstractNumericType {
         }
         return expression;
     }
-    jsonZodSchema(_parameters) {
+    jsonSchema(_parameters) {
         switch (this.primitiveIn.length) {
             case 0:
                 return code `${imports.z}.string()`;

package/dist/generators/ts/BlankNodeType.d.ts

@@ -14,7 +14,7 @@ export declare class BlankNodeType extends AbstractIdentifierType<BlankNode> {
     constructor(superParameters: Pick<ConstructorParameters<typeof AbstractIdentifierType<BlankNode>>[0], "comment" | "label">);
     fromJsonExpression({ variables, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["fromJsonExpression"]>[0]): Code;
     jsonType(parameters?: Parameters<AbstractTermType["jsonType"]>[0]): AbstractTermType.JsonType;
-    jsonZodSchema({ includeDiscriminantProperty, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["jsonZodSchema"]>[0]): Code;
+    jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["jsonSchema"]>[0]): Code;
     toJsonExpression({ includeDiscriminantProperty, variables, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["toJsonExpression"]>[0]): Code;
     protected fromRdfExpressionChain({ variables, }: Parameters<AbstractTermType["fromRdfExpressionChain"]>[0]): {
         valueTo: Code;

package/dist/generators/ts/BlankNodeType.js

@@ -35,7 +35,7 @@ export class BlankNodeType extends AbstractIdentifierType {
             : "";
         return new AbstractTermType.JsonType(code `{ readonly "@id": string${discriminantProperty} }`);
     }
-    jsonZodSchema({ includeDiscriminantProperty, }) {
+    jsonSchema({ includeDiscriminantProperty, }) {
         const discriminantProperty = includeDiscriminantProperty
             ? code `, termType: ${imports.z}.literal("BlankNode")`
             : "";

package/dist/generators/ts/BooleanType.d.ts

@@ -15,7 +15,7 @@ export declare class BooleanType extends AbstractPrimitiveType<boolean> {
         languageIn: import("ts-poet/build/Node.js").Node[] | undefined;
         kind: Code;
     };
-    jsonZodSchema(_parameters: Parameters<AbstractPrimitiveType<number>["jsonZodSchema"]>[0]): Code;
+    jsonSchema(_parameters: Parameters<AbstractPrimitiveType<number>["jsonSchema"]>[0]): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<boolean>["toRdfResourceValuesExpression"]>[0]): Code;
     protected fromRdfExpressionChain({ variables, }: Parameters<AbstractPrimitiveType<boolean>["fromRdfExpressionChain"]>[0]): ReturnType<AbstractPrimitiveType<boolean>["fromRdfExpressionChain"]>;
 }

package/dist/generators/ts/BooleanType.js

@@ -31,7 +31,7 @@ export class BooleanType extends AbstractPrimitiveType {
             in: this.primitiveIn.length > 0 ? this.primitiveIn.concat() : undefined,
         };
     }
-    jsonZodSchema(_parameters) {
+    jsonSchema(_parameters) {
         if (this.primitiveIn.length === 1) {
             return code `${imports.z}.literal(${this.primitiveIn[0]})`;
         }

package/dist/generators/ts/DateTimeType.d.ts

@@ -3,7 +3,7 @@ import { type Code } from "./ts-poet-wrapper.js";
 export declare class DateTimeType extends AbstractDateType {
     readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
     readonly kind = "DateTimeType";
-    jsonZodSchema(_parameters: Parameters<AbstractDateType["jsonZodSchema"]>[0]): Code;
+    jsonSchema(_parameters: Parameters<AbstractDateType["jsonSchema"]>[0]): Code;
     toJsonExpression({ variables, }: Parameters<AbstractDateType["toJsonExpression"]>[0]): Code;
     protected fromRdfResourceValueExpression({ variables, }: Parameters<AbstractDateType["fromRdfResourceValueExpression"]>[0]): Code;
 }

package/dist/generators/ts/DateTimeType.js

@@ -4,7 +4,7 @@ import { code } from "./ts-poet-wrapper.js";
 export class DateTimeType extends AbstractDateType {
     graphqlType = new AbstractDateType.GraphqlType(code `${imports.GraphQLDateTime}`);
     kind = "DateTimeType";
-    jsonZodSchema(_parameters) {
+    jsonSchema(_parameters) {
         return code `${imports.z}.iso.datetime()`;
     }
     toJsonExpression({ variables, }) {

package/dist/generators/ts/DateType.d.ts

@@ -4,7 +4,7 @@ import { type Code } from "./ts-poet-wrapper.js";
 export declare class DateType extends AbstractDateType {
     readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
     readonly kind = "DateType";
-    jsonZodSchema(_parameters: Parameters<DateTimeType["jsonZodSchema"]>[0]): Code;
+    jsonSchema(_parameters: Parameters<DateTimeType["jsonSchema"]>[0]): Code;
     toJsonExpression({ variables, }: Parameters<AbstractDateType["toJsonExpression"]>[0]): Code;
     protected fromRdfResourceValueExpression({ variables, }: Parameters<AbstractDateType["fromRdfResourceValueExpression"]>[0]): Code;
 }

package/dist/generators/ts/DateType.js

@@ -5,7 +5,7 @@ import { code } from "./ts-poet-wrapper.js";
 export class DateType extends AbstractDateType {
     graphqlType = new DateTimeType.GraphqlType(code `${imports.GraphQLDate}`);
     kind = "DateType";
-    jsonZodSchema(_parameters) {
+    jsonSchema(_parameters) {
         return code `${imports.z}.iso.date()`;
     }
     toJsonExpression({ variables, }) {

package/dist/generators/ts/DefaultValueType.d.ts

@@ -37,7 +37,7 @@ export declare class DefaultValueType<ItemTypeT extends DefaultValueType.ItemTyp
     hashStatements(parameters: Parameters<AbstractContainerType<ItemTypeT>["hashStatements"]>[0]): readonly Code[];
     jsonType(parameters?: Parameters<AbstractContainerType<ItemTypeT>["jsonType"]>[0]): AbstractType.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(parameters: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
     toRdfResourceValuesExpression(parameters: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
 }

package/dist/generators/ts/DefaultValueType.js

@@ -104,7 +104,7 @@ export class DefaultValueType extends AbstractContainerType {
                 return Maybe.of(this.defaultValueTermExpression);
             case "AnonymousUnionType":
             case "ListType":
-            case "ObjectType":
+            case "NamedObjectType":
             case "NamedObjectUnionType":
             case "NamedUnionType":
                 return Maybe.empty();
@@ -139,8 +139,8 @@ export class DefaultValueType extends AbstractContainerType {
     jsonUiSchemaElement(parameters) {
         return this.itemType.jsonUiSchemaElement(parameters);
     }
-    jsonZodSchema(parameters) {
-        return this.itemType.jsonZodSchema(parameters);
+    jsonSchema(parameters) {
+        return this.itemType.jsonSchema(parameters);
     }
     toJsonExpression(parameters) {
         return this.itemType.toJsonExpression(parameters);

package/dist/generators/ts/IdentifierType.d.ts

@@ -15,7 +15,7 @@ export declare class IdentifierType extends AbstractIdentifierType<BlankNode | N
     constructor(parameters: Pick<ConstructorParameters<typeof AbstractIdentifierType<BlankNode | NamedNode>>[0], "comment" | "label">);
     fromJsonExpression({ variables, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["fromJsonExpression"]>[0]): Code;
     jsonType(parameters?: Parameters<AbstractTermType["jsonType"]>[0]): AbstractTermType.JsonType;
-    jsonZodSchema({ includeDiscriminantProperty, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["jsonZodSchema"]>[0]): Code;
+    jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["jsonSchema"]>[0]): Code;
     toJsonExpression({ includeDiscriminantProperty, variables, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["toJsonExpression"]>[0]): Code;
     protected fromRdfExpressionChain({ variables, }: Parameters<AbstractTermType["fromRdfExpressionChain"]>[0]): ReturnType<AbstractTermType["fromRdfExpressionChain"]>;
 }

package/dist/generators/ts/IdentifierType.js

@@ -36,7 +36,7 @@ export class IdentifierType extends AbstractIdentifierType {
             : "";
         return new AbstractTermType.JsonType(code `{ readonly "@id": string${discriminantProperty} }`);
     }
-    jsonZodSchema({ includeDiscriminantProperty, }) {
+    jsonSchema({ includeDiscriminantProperty, }) {
         const discriminantProperty = includeDiscriminantProperty
             ? code `, termType: ${imports.z}.enum(${arrayOf(...this.nodeKinds)})`
             : "";

package/dist/generators/ts/IriType.d.ts

@@ -17,7 +17,7 @@ export declare class IriType extends AbstractIdentifierType<NamedNode> {
     };
     fromJsonExpression({ variables, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["fromJsonExpression"]>[0]): Code;
     jsonType(parameters?: Parameters<AbstractTermType["jsonType"]>[0]): AbstractTermType.JsonType;
-    jsonZodSchema({ includeDiscriminantProperty, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["jsonZodSchema"]>[0]): Code;
+    jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["jsonSchema"]>[0]): Code;
     toJsonExpression({ includeDiscriminantProperty, variables, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["toJsonExpression"]>[0]): Code;
     protected fromRdfExpressionChain({ variables, }: Parameters<AbstractTermType["fromRdfExpressionChain"]>[0]): ReturnType<AbstractTermType["fromRdfExpressionChain"]>;
 }

package/dist/generators/ts/IriType.js

@@ -63,7 +63,7 @@ export function fromString(identifier: string): ${imports.Either}<Error, ${this.
         }
         return new AbstractTermType.JsonType(code `{ readonly "@id": string${discriminantProperty} }`);
     }
-    jsonZodSchema({ includeDiscriminantProperty, }) {
+    jsonSchema({ includeDiscriminantProperty, }) {
         let idSchema;
         if (this.in_.length > 0) {
             // Treat sh:in as a union of the IRIs

package/dist/generators/ts/LazyObjectOptionType.js

@@ -28,7 +28,7 @@ export class LazyObjectOptionType extends Super {
     }
     get conversions() {
         const conversions = super.conversions.concat();
-        if (this.partialType.itemType.kind === "ObjectType") {
+        if (this.partialType.itemType.kind === "NamedObjectType") {
             conversions.push({
                 conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${value}.map(object => ${this.partialType.itemType.newExpression({ parameters: code `object` })}), resolver: async () => ${imports.Right}((${value} as ${imports.Maybe}<${this.resolveType.itemType.name}>).unsafeCoerce()) })`,
                 sourceTypeCheckExpression: (value) => code `${imports.Maybe}.isMaybe(${value})`,

package/dist/generators/ts/LazyObjectSetType.js

@@ -34,7 +34,7 @@ export class LazyObjectSetType extends AbstractLazyObjectType {
     }
     get conversions() {
         const conversions = super.conversions.concat();
-        if (this.partialType.itemType.kind === "ObjectType") {
+        if (this.partialType.itemType.kind === "NamedObjectType") {
             conversions.push({
                 conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${value}.map(object => ${this.partialType.itemType.newExpression({ parameters: code `object` })}), resolver: async () => ${imports.Right}(${value} as readonly ${this.resolveType.itemType.name}[]) })`,
                 sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,

package/dist/generators/ts/LazyObjectType.js

@@ -20,10 +20,10 @@ export class LazyObjectType extends AbstractLazyObjectType {
     }
     get conversions() {
         const conversions = super.conversions.concat();
-        if (this.partialType.kind === "ObjectType") {
+        if (this.partialType.kind === "NamedObjectType") {
             conversions.push({
                 conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${this.partialType.newExpression({ parameters: value })}, resolver: async () => ${imports.Right}(${value} as ${this.resolveType.name}) })`,
-                // Don't check instanceof value since the ObjectType may be an interface
+                // Don't check instanceof value since the NamedObjectType may be an interface
                 // Rely on the fact that this will be the last type check on an object
                 sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
                 sourceTypeName: this.resolveType.name,

package/dist/generators/ts/ListType.d.ts

@@ -14,9 +14,9 @@ import type { IdentifierType } from "./IdentifierType.js";
 import type { IntType } from "./IntType.js";
 import type { IriType } from "./IriType.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 { StringType } from "./StringType.js";
 import type { TermType } from "./TermType.js";
 import type { Type } from "./Type.js";
@@ -38,7 +38,7 @@ export declare class ListType<ItemTypeT extends ListType.ItemType> extends Abstr
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["toRdfResourceValuesExpression"]>[0]): Code;
 }
 export declare namespace ListType {
-    type ItemType = AnonymousUnionType | BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | FloatType | IdentifierType | IntType | IriType | LiteralType | NamedObjectUnionType | NamedUnionType | ObjectType | StringType | TermType;
+    type ItemType = AnonymousUnionType | BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | FloatType | IdentifierType | IntType | IriType | LiteralType | NamedObjectUnionType | NamedUnionType | NamedObjectType | StringType | TermType;
     function isItemType(type: Type): type is ItemType;
 }
 //# sourceMappingURL=ListType.d.ts.map