@shaclmate/compiler 4.0.8 → 4.0.10

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

@@ -12,13 +12,13 @@ import { removeUndefined } from "../removeUndefined.js";
 import { snippets } from "../snippets.js";
 import { arrayOf, code, literalOf } from "../ts-poet-wrapper.js";
 import { AbstractProperty } from "./AbstractProperty.js";
-export class TypeDiscriminantProperty extends AbstractProperty {
+export class DiscriminantProperty extends AbstractProperty {
     constructorParametersSignature = Maybe.empty();
     equalsFunction = Maybe.of(code `${snippets.strictEquals}`);
     filterProperty = Maybe.empty();
     getAccessorDeclaration = Maybe.empty();
     graphqlField = Maybe.empty();
-    kind = "TypeDiscriminantProperty";
+    kind = "DiscriminantProperty";
     mutable = false;
     recursive = false;
     constructor({ type, ...superParameters }) {
@@ -26,20 +26,20 @@ export class TypeDiscriminantProperty 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 TypeDiscriminantProperty 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 TypeDiscriminantProperty extends AbstractProperty {
         }
     }
     fromJsonStatements() {
-        return !this.abstract && this.objectType.declarationType === "interface"
+        return !this.abstract &&
+            this.namedObjectType.declarationType === "interface"
             ? [code `const ${this.name} = ${this.initializer};`]
             : [];
     }
-    fromRdfExpression() {
-        return !this.abstract && this.objectType.declarationType === "interface"
-            ? Maybe.of(code `${imports.Right}<${literalOf(this.objectType.discriminantValue)}>(${this.initializer})`)
+    fromRdfResourceValuesExpression() {
+        return !this.abstract &&
+            this.namedObjectType.declarationType === "interface"
+            ? Maybe.of(code `${imports.Right}<${literalOf(this.namedObjectType.discriminantValue)}>(${this.initializer})`)
             : Maybe.empty();
     }
     hashStatements({ variables, }) {
@@ -93,17 +95,17 @@ export class TypeDiscriminantProperty extends AbstractProperty {
     toJsonObjectMemberExpression({ variables, }) {
         return Maybe.of(code `${this.name}: ${variables.value}`);
     }
-    toRdfStatements() {
+    toRdfRdfResourceValuesStatements() {
         return [];
     }
 }
 __decorate([
     Memoize()
-], TypeDiscriminantProperty.prototype, "jsonSignature", null);
+], DiscriminantProperty.prototype, "jsonSignature", null);
 __decorate([
     Memoize()
-], TypeDiscriminantProperty.prototype, "jsonZodSchema", null);
-(function (TypeDiscriminantProperty) {
+], DiscriminantProperty.prototype, "jsonZchema", null);
+(function (DiscriminantProperty) {
     class Type {
         filterFunction = code `nonextant`;
         mutable;
@@ -137,6 +139,6 @@ __decorate([
     __decorate([
         Memoize()
     ], Type.prototype, "values", null);
-    TypeDiscriminantProperty.Type = Type;
-})(TypeDiscriminantProperty || (TypeDiscriminantProperty = {}));
-//# sourceMappingURL=TypeDiscriminantProperty.js.map
+    DiscriminantProperty.Type = Type;
+})(DiscriminantProperty || (DiscriminantProperty = {}));
+//# sourceMappingURL=DiscriminantProperty.js.map

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;
@@ -21,12 +21,12 @@ export declare class IdentifierPrefixProperty extends AbstractProperty<StringTyp
     get getAccessorDeclaration(): Maybe<Code>;
     constructorStatements({ variables, }: Parameters<AbstractProperty<StringType>["constructorStatements"]>[0]): readonly Code[];
     fromJsonStatements(): readonly Code[];
-    fromRdfExpression(): Maybe<Code>;
+    fromRdfResourceValuesExpression(): Maybe<Code>;
     hashStatements(): readonly Code[];
     jsonUiSchemaElement(): Maybe<Code>;
     sparqlConstructTriplesExpression(): Maybe<Code>;
     sparqlWherePatternsExpression(): ReturnType<AbstractProperty<StringType>["sparqlWherePatternsExpression"]>;
     toJsonObjectMemberExpression(): Maybe<Code>;
-    toRdfStatements(): readonly Code[];
+    toRdfRdfResourceValuesStatements(): readonly Code[];
 }
 //# sourceMappingURL=IdentifierPrefixProperty.d.ts.map

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};`])
@@ -61,7 +61,7 @@ protected ${!this.own ? "override " : ""} get ${this.name}(): ${this.type.name}
     fromJsonStatements() {
         return [];
     }
-    fromRdfExpression() {
+    fromRdfResourceValuesExpression() {
         return Maybe.empty();
     }
     hashStatements() {
@@ -79,7 +79,7 @@ protected ${!this.own ? "override " : ""} get ${this.name}(): ${this.type.name}
     toJsonObjectMemberExpression() {
         return Maybe.empty();
     }
-    toRdfStatements() {
+    toRdfRdfResourceValuesStatements() {
         return [];
     }
 }

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

@@ -28,14 +28,14 @@ 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();
     private get override();
     constructorStatements({ variables, }: Parameters<AbstractProperty<IdentifierType>["constructorStatements"]>[0]): readonly Code[];
     fromJsonStatements({ variables, }: Parameters<AbstractProperty<IdentifierType>["fromJsonStatements"]>[0]): readonly Code[];
-    fromRdfExpression({ variables, }: Parameters<AbstractProperty<IdentifierType>["fromRdfExpression"]>[0]): Maybe<Code>;
+    fromRdfResourceValuesExpression({ variables, }: Parameters<AbstractProperty<IdentifierType>["fromRdfResourceValuesExpression"]>[0]): Maybe<Code>;
     hashStatements({ variables, }: Parameters<AbstractProperty<IdentifierType>["hashStatements"]>[0]): readonly Code[];
     jsonUiSchemaElement({ variables, }: Parameters<AbstractProperty<IdentifierType>["jsonUiSchemaElement"]>[0]): Maybe<Code>;
     sparqlConstructTriplesExpression(): Maybe<Code>;
@@ -44,6 +44,6 @@ export declare class IdentifierProperty extends AbstractProperty<BlankNodeType |
         patterns: Code;
     }>;
     toJsonObjectMemberExpression({ variables, }: Parameters<AbstractProperty<IdentifierType>["toJsonObjectMemberExpression"]>[0]): Maybe<Code>;
-    toRdfStatements(): readonly Code[];
+    toRdfRdfResourceValuesStatements(): readonly Code[];
 }
 //# sourceMappingURL=IdentifierProperty.d.ts.map

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.
                 }
@@ -143,9 +143,12 @@ export class IdentifierProperty extends AbstractProperty {
         });
     }
     get jsonSignature() {
+        if (this.type.in_.length > 0) {
+            return Maybe.of(code `readonly "@id": ${this.type.in_.map((iri) => `"${iri.value}"`).join(" | ")}`);
+        }
         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
@@ -169,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",
             });
@@ -204,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}`;
@@ -215,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();
@@ -225,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 [];
@@ -244,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());
@@ -257,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}; }`);
@@ -277,8 +280,8 @@ export class IdentifierProperty extends AbstractProperty {
             code `const ${this.name} = ${this.type.fromJsonExpression({ variables: { value: variables.jsonObject } })};`,
         ];
     }
-    fromRdfExpression({ variables, }) {
-        return Maybe.of(code `${this.type.fromRdfExpression({
+    fromRdfResourceValuesExpression({ variables, }) {
+        return Maybe.of(code `${this.type.fromRdfResourceValuesExpression({
             variables: {
                 ...variables,
                 propertyPath: rdfjsTermExpression(rdf.subject),
@@ -298,12 +301,12 @@ export class IdentifierProperty extends AbstractProperty {
     sparqlWherePatternsExpression({ variables, }) {
         return Maybe.of({
             condition: code `${variables.focusIdentifier}.termType === "Variable"`,
-            patterns: code `${this.type.sparqlWherePatternsFunction}(${{
+            patterns: code `${this.type.valueSparqlWherePatternsFunction}(${{
                 filter: code `${variables.filter}?.${this.name}`,
                 ignoreRdfType: true, // Unused
                 preferredLanguages: variables.preferredLanguages,
                 propertyPatterns: code `[]`,
-                schema: code `${this.objectType.staticModuleName}.${syntheticNamePrefix}schema.properties.${this.objectType.identifierProperty.name}.type()`,
+                schema: code `${this.namedObjectType.staticModuleName}.${syntheticNamePrefix}schema.properties.${this.namedObjectType.identifierProperty.name}.type()`,
                 valueVariable: variables.focusIdentifier,
                 variablePrefix: variables.variablePrefix, // Unused
             }})`,
@@ -327,7 +330,7 @@ export class IdentifierProperty extends AbstractProperty {
         invariant(valueToNodeKinds.length === 2);
         return Maybe.of(code `"@id": ${variables.value}.termType === "${NodeKind.toTermType(nodeKinds[0])}" ? ${valueToNodeKinds[0]} : ${valueToNodeKinds[1]}`);
     }
-    toRdfStatements() {
+    toRdfRdfResourceValuesStatements() {
         return [];
     }
 }
@@ -354,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_toRdfFunctionOrMethodDeclaration } from "./ObjectType_toRdfFunctionOrMethodDeclaration.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,29 +41,29 @@ constructor(${statements.length > 0 ? "parameters" : "_parameters"}${parametersH
 ${joinCode(statements)}
 }`;
 }
-export function ObjectType_classDeclaration() {
+export function NamedObjectType_classDeclaration() {
     this.ensureAtMostOneSuperObjectType();
     return code `\
 ${this.comment
         .alt(this.label)
         .map(tsComment)
-        .orDefault("")}${this.export ? "export " : ""}${this.abstract ? "abstract " : ""}class ${def(this.name)}${this.parentObjectTypes.length > 0 ? ` extends ${this.parentObjectTypes[0].name}` : ""} {
+        .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.bind(this)(),
+        NamedObjectType_constructorDeclaration.call(this),
         ...this.properties.flatMap((property) => property.getAccessorDeclaration.toList()),
-        ...ObjectType_equalsFunctionOrMethodDeclaration.bind(this)().toList(),
-        ...ObjectType_hashFunctionOrMethodDeclarations.bind(this)(),
-        ...ObjectType_toJsonFunctionOrMethodDeclaration.bind(this)().toList(),
-        ...ObjectType_toRdfFunctionOrMethodDeclaration.bind(this)().toList(),
-        ...ObjectType_toStringMethodDeclaration.bind(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_sparqlConstructTriplesFunctionDeclaration.js → _NamedObjectType/NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration.js}

@@ -2,6 +2,7 @@ import { rdf, rdfs } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
 import { imports } from "../imports.js";
 import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
+import { snippets } from "../snippets.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
 const variables = {
@@ -9,7 +10,7 @@ const variables = {
     focusIdentifier: code `parameters.focusIdentifier`,
     variablePrefix: code `parameters.variablePrefix`,
 };
-export function ObjectType_sparqlConstructTriplesFunctionDeclaration() {
+export function NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration() {
     if (!this.features.has("sparql")) {
         return Maybe.empty();
     }
@@ -18,7 +19,7 @@ export function ObjectType_sparqlConstructTriplesFunctionDeclaration() {
     let triplesVariableDeclarationKeyword = "const";
     const statements = [];
     for (const parentObjectType of this.parentObjectTypes) {
-        statements.push(code `triples = triples.concat(${parentObjectType.staticModuleName}.${syntheticNamePrefix}sparqlConstructTriples(${{ filter: variables.filter, focusIdentifier: variables.focusIdentifier, ignoreRdfType: true, variablePrefix: variables.variablePrefix }}));`);
+        statements.push(code `triples = triples.concat(${parentObjectType.staticModuleName}.${syntheticNamePrefix}focusSparqlConstructTriples(${{ filter: variables.filter, focusIdentifier: variables.focusIdentifier, ignoreRdfType: true, variablePrefix: variables.variablePrefix }}));`);
         triplesVariableDeclarationKeyword = "let";
     }
     if (this.fromRdfType.isJust()) {
@@ -44,7 +45,7 @@ if (!parameters?.ignoreRdfType) {
         });
     }
     return Maybe.of(code `\
-export function ${syntheticNamePrefix}sparqlConstructTriples(${statements.length === 0 ? "_" : ""}parameters: { filter: ${this.filterType} | undefined; focusIdentifier: ${imports.NamedNode} | ${imports.Variable}; ignoreRdfType: boolean;  variablePrefix: string }): readonly ${imports.sparqljs}.Triple[] {
+export const ${syntheticNamePrefix}focusSparqlConstructTriples: ${snippets.FocusSparqlConstructTriplesFunction}<${this.filterType}> = (${statements.length === 0 ? "_" : ""}parameters) => {
 ${statements.length > 0
         ? joinCode([
             code `${triplesVariableDeclarationKeyword} triples: ${imports.sparqljs}.Triple[] = [];`,
@@ -52,6 +53,6 @@ ${statements.length > 0
             code `return triples;`,
         ])
         : "return [];"}
-}`);
+};`);
 }
-//# sourceMappingURL=ObjectType_sparqlConstructTriplesFunctionDeclaration.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