@shaclmate/compiler 4.0.9 → 4.0.10

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

@@ -39,8 +39,8 @@ export class IdentifierProperty extends AbstractProperty {
             }
         }
         const hasQuestionToken = this.identifierMintingStrategy.isJust() ||
-            this.objectType.ancestorObjectTypes.some((ancestorObjectType) => ancestorObjectType.identifierProperty.identifierMintingStrategy.isJust()) ||
-            this.objectType.descendantObjectTypes.some((descendantObjectType) => descendantObjectType.identifierProperty.identifierMintingStrategy.isJust());
+            this.namedObjectType.ancestorObjectTypes.some((ancestorObjectType) => ancestorObjectType.identifierProperty.identifierMintingStrategy.isJust()) ||
+            this.namedObjectType.descendantObjectTypes.some((descendantObjectType) => descendantObjectType.identifierProperty.identifierMintingStrategy.isJust());
         const typeNames = [];
         for (const conversion of this.type.conversions) {
             if (conversion.sourceTypeof !== "undefined" &&
@@ -91,7 +91,7 @@ export class IdentifierProperty extends AbstractProperty {
                     break;
                 case "sha256":
                     // If the object is mutable don't memoize the minted identifier, since the hash will change if the object mutates.
-                    memoizeMintedIdentifier = !this.objectType.mutable;
+                    memoizeMintedIdentifier = !this.namedObjectType.mutable;
                     mintIdentifier = code `${imports.dataFactory}.namedNode(\`\${this.${this.identifierPrefixPropertyName}}\${this.${syntheticNamePrefix}hashShaclProperties(${imports.sha256}.create())}\`)`;
                     break;
                 case "uuidv4":
@@ -107,11 +107,11 @@ export class IdentifierProperty extends AbstractProperty {
             ])} }`);
         }
         // If this object type has an ancestor or a descendant with an identifier minting strategy, declare a get accessor.
-        if (this.objectType.ancestorObjectTypes.some((ancestorObjectType) => ancestorObjectType.identifierProperty.identifierMintingStrategy.isJust()) ||
-            this.objectType.descendantObjectTypes.some((descendantObjectType) => descendantObjectType.identifierProperty.identifierMintingStrategy.isJust())) {
-            if (this.objectType.parentObjectTypes.length > 0) {
+        if (this.namedObjectType.ancestorObjectTypes.some((ancestorObjectType) => ancestorObjectType.identifierProperty.identifierMintingStrategy.isJust()) ||
+            this.namedObjectType.descendantObjectTypes.some((descendantObjectType) => descendantObjectType.identifierProperty.identifierMintingStrategy.isJust())) {
+            if (this.namedObjectType.parentObjectTypes.length > 0) {
                 // If this object type isn't the root, delegate up.
-                const checkSuperIdentifierTermTypeStatements = checkIdentifierTermTypeStatements("identifier", this.objectType.parentObjectTypes[0].identifierType.nodeKinds);
+                const checkSuperIdentifierTermTypeStatements = checkIdentifierTermTypeStatements("identifier", this.namedObjectType.parentObjectTypes[0].identifierType.nodeKinds);
                 if (checkSuperIdentifierTermTypeStatements.length === 0) {
                     return Maybe.empty(); // Don't need a get accessor just to return super.identifier.
                 }
@@ -148,7 +148,7 @@ export class IdentifierProperty extends AbstractProperty {
         }
         return Maybe.of(code `readonly "@id": string`);
     }
-    get jsonZodSchema() {
+    get jsonZchema() {
         let schema;
         if (this.type.in_.length > 0 && this.type.kind === "IriType") {
             // Treat sh:in as a union of the IRIs
@@ -172,22 +172,22 @@ export class IdentifierProperty extends AbstractProperty {
     //   };
     // }
     get abstract() {
-        return this.objectType.abstract;
+        return this.namedObjectType.abstract;
     }
     get declarationModifiers() {
-        if (this.objectType.declarationType === "interface") {
+        if (this.namedObjectType.declarationType === "interface") {
             return Maybe.of({ readonly: true });
         }
-        if (this.objectType.parentObjectTypes.length > 0) {
+        if (this.namedObjectType.parentObjectTypes.length > 0) {
             // An ancestor will declare the identifier property.
             return Maybe.empty();
         }
         if (this.identifierMintingStrategy.isJust() ||
-            this.objectType.ancestorObjectTypes.some((ancestorObjectType) => ancestorObjectType.identifierProperty.identifierMintingStrategy.isJust()) ||
-            this.objectType.descendantObjectTypes.some((descendantObjectType) => descendantObjectType.identifierProperty.identifierMintingStrategy.isJust())) {
+            this.namedObjectType.ancestorObjectTypes.some((ancestorObjectType) => ancestorObjectType.identifierProperty.identifierMintingStrategy.isJust()) ||
+            this.namedObjectType.descendantObjectTypes.some((descendantObjectType) => descendantObjectType.identifierProperty.identifierMintingStrategy.isJust())) {
             return Maybe.of({
                 hasQuestionToken: true,
-                visibility: this.objectType.descendantObjectTypes.some((descendantObjectType) => descendantObjectType.identifierProperty.identifierMintingStrategy.isJust())
+                visibility: this.namedObjectType.descendantObjectTypes.some((descendantObjectType) => descendantObjectType.identifierProperty.identifierMintingStrategy.isJust())
                     ? "protected"
                     : "private",
             });
@@ -207,10 +207,10 @@ export class IdentifierProperty extends AbstractProperty {
         });
     }
     get declarationName() {
-        if (this.objectType.declarationType === "class" &&
+        if (this.namedObjectType.declarationType === "class" &&
             (this.identifierMintingStrategy.isJust() ||
-                this.objectType.ancestorObjectTypes.some((ancestorObjectType) => ancestorObjectType.identifierProperty.identifierMintingStrategy.isJust()) ||
-                this.objectType.descendantObjectTypes.some((descendantObjectType) => descendantObjectType.identifierProperty.identifierMintingStrategy.isJust()))) {
+                this.namedObjectType.ancestorObjectTypes.some((ancestorObjectType) => ancestorObjectType.identifierProperty.identifierMintingStrategy.isJust()) ||
+                this.namedObjectType.descendantObjectTypes.some((descendantObjectType) => descendantObjectType.identifierProperty.identifierMintingStrategy.isJust()))) {
             // If this, an ancestor, or a descendant has an identifier minting strategy, declare the identifier property
             // private or protected and prefix its name with _ in order to avoid a conflict with the get accessor name.
             return `_${this.name}`;
@@ -218,7 +218,7 @@ export class IdentifierProperty extends AbstractProperty {
         return this.name;
     }
     get override() {
-        return this.objectType.parentObjectTypes.length > 0;
+        return this.namedObjectType.parentObjectTypes.length > 0;
     }
     constructorStatements({ variables, }) {
         const constructorParametersSignature = this.constructorParametersSignature.extractNullable();
@@ -228,7 +228,7 @@ export class IdentifierProperty extends AbstractProperty {
         let lhs;
         const statements = [];
         const typeConversions = this.type.conversions;
-        switch (this.objectType.declarationType) {
+        switch (this.namedObjectType.declarationType) {
             case "class": {
                 if (this.declaration.isNothing()) {
                     return [];
@@ -247,7 +247,7 @@ export class IdentifierProperty extends AbstractProperty {
             conversionBranches.push(code `if (${conversion.sourceTypeCheckExpression(variables.parameter)}) { ${lhs} = ${conversion.conversionExpression(variables.parameter)}; }`);
         }
         this.identifierMintingStrategy.ifJust((identifierMintingStrategy) => {
-            switch (this.objectType.declarationType) {
+            switch (this.namedObjectType.declarationType) {
                 case "class":
                     // The identifier will be minted lazily in the get accessor
                     invariant(this.getAccessorDeclaration.isJust());
@@ -260,10 +260,10 @@ export class IdentifierProperty extends AbstractProperty {
                             mintIdentifier = code `${imports.dataFactory}.blankNode()`;
                             break;
                         case "sha256":
-                            logger.warn("minting %s identifiers with %s is unsupported", this.objectType.declarationType, identifierMintingStrategy);
+                            logger.warn("minting %s identifiers with %s is unsupported", this.namedObjectType.declarationType, identifierMintingStrategy);
                             return;
                         case "uuidv4":
-                            mintIdentifier = code `${imports.dataFactory}.namedNode(\`\${${variables.parameters}.${this.identifierPrefixPropertyName} ?? "urn:shaclmate:${this.objectType.discriminantValue}:"}\${${imports.uuid}.v4()}\`)`;
+                            mintIdentifier = code `${imports.dataFactory}.namedNode(\`\${${variables.parameters}.${this.identifierPrefixPropertyName} ?? "urn:shaclmate:${this.namedObjectType.discriminantValue}:"}\${${imports.uuid}.v4()}\`)`;
                             break;
                     }
                     conversionBranches.push(code `if (${variables.parameter} === undefined) { ${lhs} = ${mintIdentifier}; }`);
@@ -306,7 +306,7 @@ export class IdentifierProperty extends AbstractProperty {
                 ignoreRdfType: true, // Unused
                 preferredLanguages: variables.preferredLanguages,
                 propertyPatterns: code `[]`,
-                schema: code `${this.objectType.staticModuleName}.${syntheticNamePrefix}schema.properties.${this.objectType.identifierProperty.name}.type()`,
+                schema: code `${this.namedObjectType.staticModuleName}.${syntheticNamePrefix}schema.properties.${this.namedObjectType.identifierProperty.name}.type()`,
                 valueVariable: variables.focusIdentifier,
                 variablePrefix: variables.variablePrefix, // Unused
             }})`,
@@ -357,7 +357,7 @@ __decorate([
 ], IdentifierProperty.prototype, "jsonSignature", null);
 __decorate([
     Memoize()
-], IdentifierProperty.prototype, "jsonZodSchema", null);
+], IdentifierProperty.prototype, "jsonZchema", null);
 __decorate([
     Memoize()
 ], IdentifierProperty.prototype, "declarationModifiers", null);

package/dist/generators/ts/_NamedObjectType/NamedObjectType_classDeclaration.d.ts

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

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

@@ -2,11 +2,11 @@ import { Maybe } from "purify-ts";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, def, joinCode } from "../ts-poet-wrapper.js";
 import { tsComment } from "../tsComment.js";
-import { ObjectType_equalsFunctionOrMethodDeclaration } from "./ObjectType_equalsFunctionOrMethodDeclaration.js";
-import { ObjectType_hashFunctionOrMethodDeclarations } from "./ObjectType_hashFunctionOrMethodDeclarations.js";
-import { ObjectType_toJsonFunctionOrMethodDeclaration } from "./ObjectType_toJsonFunctionOrMethodDeclaration.js";
-import { ObjectType_toRdfResourceFunctionOrMethodDeclaration } from "./ObjectType_toRdfResourceFunctionOrMethodDeclaration.js";
-function ObjectType_constructorDeclaration() {
+import { NamedObjectType_equalsFunctionOrMethodDeclaration } from "./NamedObjectType_equalsFunctionOrMethodDeclaration.js";
+import { NamedObjectType_hashFunctionOrMethodDeclarations } from "./NamedObjectType_hashFunctionOrMethodDeclarations.js";
+import { NamedObjectType_toJsonFunctionOrMethodDeclaration } from "./NamedObjectType_toJsonFunctionOrMethodDeclaration.js";
+import { NamedObjectType_toRdfResourceFunctionOrMethodDeclaration } from "./NamedObjectType_toRdfResourceFunctionOrMethodDeclaration.js";
+function NamedObjectType_constructorDeclaration() {
     const parametersPropertySignatures = this.properties.flatMap((property) => property.constructorParametersSignature.toList());
     const parametersType = [];
     if (parametersPropertySignatures.length > 0) {
@@ -41,7 +41,7 @@ constructor(${statements.length > 0 ? "parameters" : "_parameters"}${parametersH
 ${joinCode(statements)}
 }`;
 }
-export function ObjectType_classDeclaration() {
+export function NamedObjectType_classDeclaration() {
     this.ensureAtMostOneSuperObjectType();
     return code `\
 ${this.comment
@@ -50,20 +50,20 @@ ${this.comment
         .orDefault("")}export ${this.abstract ? "abstract " : ""}class ${def(this.name)}${this.parentObjectTypes.length > 0 ? ` extends ${this.parentObjectTypes[0].name}` : ""} {
 ${joinCode([
         ...this.properties.flatMap((property) => property.declaration.toList()),
-        ObjectType_constructorDeclaration.call(this),
+        NamedObjectType_constructorDeclaration.call(this),
         ...this.properties.flatMap((property) => property.getAccessorDeclaration.toList()),
-        ...ObjectType_equalsFunctionOrMethodDeclaration.call(this).toList(),
-        ...ObjectType_hashFunctionOrMethodDeclarations.call(this),
-        ...ObjectType_toJsonFunctionOrMethodDeclaration.call(this).toList(),
-        ...ObjectType_toRdfResourceFunctionOrMethodDeclaration.call(this).toList(),
-        ...ObjectType_toStringMethodDeclaration.call(this).toList(),
+        ...NamedObjectType_equalsFunctionOrMethodDeclaration.call(this).toList(),
+        ...NamedObjectType_hashFunctionOrMethodDeclarations.call(this),
+        ...NamedObjectType_toJsonFunctionOrMethodDeclaration.call(this).toList(),
+        ...NamedObjectType_toRdfResourceFunctionOrMethodDeclaration.call(this).toList(),
+        ...NamedObjectType_toStringMethodDeclaration.call(this).toList(),
     ], { on: "\n\n" })}
 }`;
 }
-function ObjectType_toStringMethodDeclaration() {
+function NamedObjectType_toStringMethodDeclaration() {
     if (!this.features.has("json")) {
         return Maybe.empty();
     }
     return Maybe.of(code `${this.parentObjectTypes.length > 0 ? "override " : ""}toString(): string { return JSON.stringify(this.${syntheticNamePrefix}toJson()); }`);
 }
-//# sourceMappingURL=ObjectType_classDeclaration.js.map
+//# sourceMappingURL=NamedObjectType_classDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_createFunctionDeclaration.d.ts

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

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

@@ -2,7 +2,7 @@ import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectType_createFunctionDeclaration() {
+export function NamedObjectType_createFunctionDeclaration() {
     if (!this.features.has("create")) {
         return Maybe.empty();
     }
@@ -49,4 +49,4 @@ export function ${syntheticNamePrefix}create(parameters${parametersHasQuestionTo
   return { ${propertyInitializers.join(", ")} };
 }`);
 }
-//# sourceMappingURL=ObjectType_createFunctionDeclaration.js.map
+//# sourceMappingURL=NamedObjectType_createFunctionDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_equalsFunctionOrMethodDeclaration.d.ts

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

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

@@ -2,7 +2,7 @@ import { Maybe } from "purify-ts";
 import { snippets } from "../snippets.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectType_equalsFunctionOrMethodDeclaration() {
+export function NamedObjectType_equalsFunctionOrMethodDeclaration() {
     if (!this.features.has("equals")) {
         return Maybe.empty();
     }
@@ -48,4 +48,4 @@ ${preamble}${syntheticNamePrefix}equals(${parameters}): ${snippets.EqualsResult}
   return ${joinCode(chain.map((chainPart, chainPartI) => chainPartI === 0 ? chainPart : code `chain(() => ${chainPart})`), { on: "." })}
 }`);
 }
-//# sourceMappingURL=ObjectType_equalsFunctionOrMethodDeclaration.js.map
+//# sourceMappingURL=NamedObjectType_equalsFunctionOrMethodDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_filterFunctionDeclaration.d.ts

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

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

@@ -1,6 +1,6 @@
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectType_filterFunctionDeclaration() {
+export function NamedObjectType_filterFunctionDeclaration() {
     const statements = [];
     for (const parentObjectType of this.parentObjectTypes) {
         statements.push(code `if (!${parentObjectType.filterFunction}(filter, value)) { return false; }`);
@@ -18,4 +18,4 @@ export function ${syntheticNamePrefix}filter(filter: ${this.filterType}, value:
   ${joinCode(statements)}
 }`;
 }
-//# sourceMappingURL=ObjectType_filterFunctionDeclaration.js.map
+//# sourceMappingURL=NamedObjectType_filterFunctionDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_filterTypeDeclaration.d.ts

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

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

@@ -1,6 +1,6 @@
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectType_filterTypeDeclaration() {
+export function NamedObjectType_filterTypeDeclaration() {
     const members = [];
     if (this.properties.length > 0) {
         const filterProperties = {};
@@ -19,4 +19,4 @@ export function ObjectType_filterTypeDeclaration() {
     return code `\
 export type ${syntheticNamePrefix}Filter = ${members.length > 0 ? joinCode(members, { on: " & " }) : "object"};`;
 }
-//# sourceMappingURL=ObjectType_filterTypeDeclaration.js.map
+//# sourceMappingURL=NamedObjectType_filterTypeDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration.d.ts

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

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

@@ -10,7 +10,7 @@ const variables = {
     focusIdentifier: code `parameters.focusIdentifier`,
     variablePrefix: code `parameters.variablePrefix`,
 };
-export function ObjectType_focusSparqlConstructTriplesFunctionDeclaration() {
+export function NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration() {
     if (!this.features.has("sparql")) {
         return Maybe.empty();
     }
@@ -55,4 +55,4 @@ ${statements.length > 0
         : "return [];"}
 };`);
 }
-//# sourceMappingURL=ObjectType_focusSparqlConstructTriplesFunctionDeclaration.js.map
+//# sourceMappingURL=NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_focusSparqlWherePatternsFunctionDeclaration.d.ts

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

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

@@ -11,7 +11,7 @@ const variables = {
     focusIdentifier: code `parameters.focusIdentifier`,
     variablePrefix: code `parameters.variablePrefix`,
 };
-export function ObjectType_focusSparqlWherePatternsFunctionDeclaration() {
+export function NamedObjectType_focusSparqlWherePatternsFunctionDeclaration() {
     if (!this.features.has("sparql")) {
         return Maybe.empty();
     }
@@ -103,4 +103,4 @@ ${statements.length > 0
         : "return [];"}
 };`);
 }
-//# sourceMappingURL=ObjectType_focusSparqlWherePatternsFunctionDeclaration.js.map
+//# sourceMappingURL=NamedObjectType_focusSparqlWherePatternsFunctionDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_fromJsonFunctionDeclaration.d.ts

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

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

@@ -1,7 +1,7 @@
 import { Maybe } from "purify-ts";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code } from "../ts-poet-wrapper.js";
-export function ObjectType_fromJsonFunctionDeclaration() {
+export function NamedObjectType_fromJsonFunctionDeclaration() {
     if (!this.features.has("json")) {
         return Maybe.empty();
     }
@@ -17,4 +17,4 @@ export function ${syntheticNamePrefix}fromJson(json: ${this.jsonType().name}): $
   return ${returnExpression};
 }`);
 }
-//# sourceMappingURL=ObjectType_fromJsonFunctionDeclaration.js.map
+//# sourceMappingURL=NamedObjectType_fromJsonFunctionDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_fromRdfResourceFunctionDeclaration.d.ts

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

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

@@ -2,7 +2,7 @@ import { Maybe } from "purify-ts";
 import { snippets } from "../snippets.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectType_fromRdfResourceFunctionDeclaration() {
+export function NamedObjectType_fromRdfResourceFunctionDeclaration() {
     if (!this.features.has("rdf")) {
         return Maybe.empty();
     }
@@ -23,4 +23,4 @@ export const ${syntheticNamePrefix}fromRdfResource: ${snippets.FromRdfResourceFu
 ${joinCode(statements)}
 };`);
 }
-//# sourceMappingURL=ObjectType_fromRdfResourceFunctionDeclaration.js.map
+//# sourceMappingURL=NamedObjectType_fromRdfResourceFunctionDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_fromRdfResourceValuesFunctionDeclaration.d.ts

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

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

@@ -2,7 +2,7 @@ import { Maybe } from "purify-ts";
 import { snippets } from "../snippets.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code } from "../ts-poet-wrapper.js";
-export function ObjectType_fromRdfResourceValuesFunctionDeclaration() {
+export function NamedObjectType_fromRdfResourceValuesFunctionDeclaration() {
     if (!this.features.has("rdf")) {
         return Maybe.empty();
     }
@@ -17,4 +17,4 @@ export const ${syntheticNamePrefix}fromRdfResourceValues: ${snippets.FromRdfReso
     )
   );`);
 }
-//# sourceMappingURL=ObjectType_fromRdfResourceValuesFunctionDeclaration.js.map
+//# sourceMappingURL=NamedObjectType_fromRdfResourceValuesFunctionDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_fromRdfTypeVariableStatement.d.ts

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

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

@@ -3,11 +3,11 @@ import { imports } from "../imports.js";
 import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code } from "../ts-poet-wrapper.js";
-export function ObjectType_fromRdfTypeVariableStatement() {
+export function NamedObjectType_fromRdfTypeVariableStatement() {
     if (!this.features.has("rdf")) {
         return Maybe.empty();
     }
     return this.fromRdfType.map((fromRdfType) => code `\
 export const ${syntheticNamePrefix}fromRdfType: ${imports.NamedNode}<string> = ${rdfjsTermExpression(fromRdfType)};`);
 }
-//# sourceMappingURL=ObjectType_fromRdfTypeVariableStatement.js.map
+//# sourceMappingURL=NamedObjectType_fromRdfTypeVariableStatement.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_graphqlTypeVariableStatement.d.ts

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

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

@@ -2,7 +2,7 @@ import { Maybe } from "purify-ts";
 import { imports } from "../imports.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code } from "../ts-poet-wrapper.js";
-export function ObjectType_graphqlTypeVariableStatement() {
+export function NamedObjectType_graphqlTypeVariableStatement() {
     if (!this.features.has("graphql")) {
         return Maybe.empty();
     }
@@ -32,4 +32,4 @@ export const ${syntheticNamePrefix}GraphQL = new ${imports.GraphQLObjectType}<${
         name: this.name,
     }});`);
 }
-//# sourceMappingURL=ObjectType_graphqlTypeVariableStatement.js.map
+//# sourceMappingURL=NamedObjectType_graphqlTypeVariableStatement.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_hashFunctionOrMethodDeclarations.d.ts

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

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

@@ -2,7 +2,7 @@ import { snippets } from "../snippets.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
 const hasherVariable = code `_hasher`;
-export function ObjectType_hashFunctionOrMethodDeclarations() {
+export function NamedObjectType_hashFunctionOrMethodDeclarations() {
     if (!this.features.has("hash")) {
         return [];
     }
@@ -70,4 +70,4 @@ ${hashShaclPropertiesPreamble}${syntheticNamePrefix}hashShaclProperties<HasherT
 }`,
     ];
 }
-//# sourceMappingURL=ObjectType_hashFunctionOrMethodDeclarations.js.map
+//# sourceMappingURL=NamedObjectType_hashFunctionOrMethodDeclarations.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_interfaceDeclaration.d.ts

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

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

@@ -1,6 +1,6 @@
 import { code, joinCode } from "../ts-poet-wrapper.js";
 import { tsComment } from "../tsComment.js";
-export function ObjectType_interfaceDeclaration() {
+export function NamedObjectType_interfaceDeclaration() {
     return code `\
 ${this.comment
         .alt(this.label)
@@ -13,4 +13,4 @@ ${this.comment
   ${joinCode(this.properties.flatMap((property) => property.declaration.toList()))}
 }`;
 }
-//# sourceMappingURL=ObjectType_interfaceDeclaration.js.map
+//# sourceMappingURL=NamedObjectType_interfaceDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_isTypeFunctionDeclaration.d.ts

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

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

@@ -1,6 +1,6 @@
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code } from "../ts-poet-wrapper.js";
-export function ObjectType_isTypeFunctionDeclaration() {
+export function NamedObjectType_isTypeFunctionDeclaration() {
     return code `\
 export function is${this.name}(object: ${syntheticNamePrefix}Object): object is ${this.name} {
   switch (object.${this._discriminantProperty.name}) {
@@ -11,4 +11,4 @@ export function is${this.name}(object: ${syntheticNamePrefix}Object): object is
   }
 }`;
 }
-//# sourceMappingURL=ObjectType_isTypeFunctionDeclaration.js.map
+//# sourceMappingURL=NamedObjectType_isTypeFunctionDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_jsonParseFunctionDeclaration.d.ts

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

package/dist/generators/ts/_NamedObjectType/NamedObjectType_jsonParseFunctionDeclaration.js

@@ -0,0 +1,19 @@
+import { Maybe } from "purify-ts";
+import { imports } from "../imports.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code } from "../ts-poet-wrapper.js";
+export function NamedObjectType_jsonParseFunctionDeclaration() {
+    if (!this.features.has("json")) {
+        return Maybe.empty();
+    }
+    if (this.abstract) {
+        return Maybe.empty();
+    }
+    return Maybe.of(code `\
+export function 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);
+}`);
+}
+//# sourceMappingURL=NamedObjectType_jsonParseFunctionDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_jsonSchemaFunctionDeclaration.d.ts

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

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

@@ -2,21 +2,21 @@ import { Maybe } from "purify-ts";
 import { imports } from "../imports.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectType_jsonZodSchemaFunctionDeclaration() {
+export function NamedObjectType_jsonSchemaFunctionDeclaration() {
     if (!this.features.has("json")) {
         return Maybe.empty();
     }
     const mergeZodObjectSchemas = [];
     for (const parentObjectType of this.parentObjectTypes) {
-        mergeZodObjectSchemas.push(parentObjectType.jsonZodSchema({ context: "type" }));
+        mergeZodObjectSchemas.push(parentObjectType.jsonSchema({ context: "type" }));
     }
     if (this.properties.length > 0) {
         mergeZodObjectSchemas.push(code `${imports.z}.object({ ${joinCode(this.properties
-            .flatMap((property) => property.jsonZodSchema.toList())
+            .flatMap((property) => property.jsonZchema.toList())
             .map(({ key, schema }) => code `"${key}": ${schema}`), { on: "," })} })`);
     }
     return Maybe.of(code `\
-export function ${syntheticNamePrefix}jsonZodSchema() {
+export function schema() {
   return ${mergeZodObjectSchemas.length > 0
         ? mergeZodObjectSchemas.reduce((merged, zodObjectSchema) => {
             if (merged === null) {
@@ -27,4 +27,4 @@ export function ${syntheticNamePrefix}jsonZodSchema() {
         : `${imports.z}.object()`} satisfies ${imports.z}.ZodType<${syntheticNamePrefix}Json>;
 }`);
 }
-//# sourceMappingURL=ObjectType_jsonZodSchemaFunctionDeclaration.js.map
+//# sourceMappingURL=NamedObjectType_jsonSchemaFunctionDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_jsonTypeAliasDeclaration.d.ts

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

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

@@ -1,7 +1,7 @@
 import { Maybe } from "purify-ts";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectType_jsonTypeAliasDeclaration() {
+export function NamedObjectType_jsonTypeAliasDeclaration() {
     if (!this.features.has("json")) {
         return Maybe.empty();
     }
@@ -14,4 +14,4 @@ export function ObjectType_jsonTypeAliasDeclaration() {
     }
     return Maybe.of(code `export type ${syntheticNamePrefix}Json = ${members.length > 0 ? joinCode(members, { on: " & " }) : "object"};`);
 }
-//# sourceMappingURL=ObjectType_jsonTypeAliasDeclaration.js.map
+//# sourceMappingURL=NamedObjectType_jsonTypeAliasDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_jsonUiSchemaFunctionDeclaration.d.ts

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