@shaclmate/compiler 4.0.94 → 4.0.95

package/dist/generators/ts/_ObjectType/ObjectType_ShaclProperty.js

@@ -14,23 +14,25 @@ export class ObjectType_ShaclProperty extends ObjectType_AbstractProperty {
     description;
     display;
     label;
+    minCount;
     kind = "Shacl";
     mutable;
     path;
     recursive;
     type;
-    constructor({ comment, description, display, label, mutable, path, recursive, type, ...superParameters }) {
+    constructor({ comment, description, display, label, minCount, mutable, path, recursive, type, ...superParameters }) {
         super(superParameters);
         this.comment = comment;
         this.description = description;
         this.display = display;
         this.label = label;
+        this.minCount = minCount;
         this.mutable = mutable;
         this.path = path;
         this.recursive = recursive;
         this.type = type;
     }
-    get constructorParameter() {
+    get createFunctionParameter() {
         const conversionFunction = this.type.conversionFunction.extract();
         if (!conversionFunction) {
             return Maybe.of({
@@ -50,7 +52,7 @@ export class ObjectType_ShaclProperty extends ObjectType_AbstractProperty {
         }
         return Maybe.of({
             hasQuestionToken,
-            signature: code `readonly ${this.name}${hasQuestionToken ? "?" : ""}: ${joinCode(typeExpressions, { on: "|" })};`,
+            signature: code `readonly ${this.name}${hasQuestionToken ? "?" : ""}: ${joinCode(typeExpressions, { on: " | " })};`,
         });
     }
     get declaration() {
@@ -84,31 +86,25 @@ export class ObjectType_ShaclProperty extends ObjectType_AbstractProperty {
     get hashFunctionParameter() {
         return this.declaration;
     }
-    get jsonSchema() {
-        let schema = this.type.jsonSchema({
-            context: "property",
-        });
-        const meta = {
-        // id: `${this.namedObjectType.name}-${this.name}`, // id's must be unique
-        };
-        this.comment.alt(this.description).ifJust((description) => {
-            meta["description"] = description;
-        });
-        this.label.ifJust((label) => {
-            meta["title"] = label;
-        });
-        if (Object.keys(meta).length > 0) {
-            schema = code `${schema}.meta(${meta})`;
-        }
+    get jsonObjectMember() {
         return Maybe.of({
-            key: this.name,
-            schema,
+            description: this.description.alt(this.comment),
+            label: this.label,
+            name: this.name,
+            optional: this.minCount === 0n && this.type.kind !== "DefaultValue",
+            recursive: this.recursive,
+            type: this.recursive
+                ? () => this.type.jsonValueType
+                : this.type.jsonValueType,
+            uiSchemaElement: Maybe.of(({ variables }) => {
+                const scope = code `\`\${${variables.scopePrefix}}/properties/${this.name}\``;
+                return this.type.jsonValueType
+                    .uiSchemaElement({ variables })
+                    .altLazy(() => Maybe.of(code `{ ${this.label.isJust() ? `label: "${this.label.unsafeCoerce()}", ` : ""}scope: ${scope}, type: "Control" }`))
+                    .unsafeCoerce();
+            }),
         });
     }
-    get jsonSignature() {
-        const typeJsonType = this.type.jsonType();
-        return Maybe.of(code `${!this.mutable ? "readonly " : ""}${this.name}${typeJsonType.optional ? "?" : ""}: ${typeJsonType.requiredExpression}`);
-    }
     get schema() {
         const initializers = [code `kind: ${literalOf(this.kind)}`];
         if (this.configuration.features.has("Object.fromRdf") ||
@@ -133,21 +129,16 @@ export class ObjectType_ShaclProperty extends ObjectType_AbstractProperty {
         initializers.push(code `readonly type: ${this.type.schemaType}`);
         return Maybe.of(code `{ ${joinCode(initializers, { on: ", " })} }`);
     }
-    get schemaVariable() {
-        return this.objectType.name
-            .map((name) => code `${name}.schema.properties.${this.name}`)
-            .orDefaultLazy(() => this.schema.unsafeCoerce());
-    }
     get typeSchemaVariable() {
         return this.objectType.name
             .map((name) => code `${name}.schema.properties.${this.name}.type`)
             .orDefaultLazy(() => this.type.schema);
     }
-    constructorInitializer({ variables, }) {
+    createInitializer({ variables, }) {
         const parameterVariable = code `${variables.parameters}.${this.name}`;
         const defaultNamespaceVariable = code `${variables.parameters}.${this.configuration.syntheticNamePrefix}defaultNamespace`;
         const conversionFunction = this.type.conversionFunction.extract()?.code;
-        const validationFunction = this.type.validationFunction.extract();
+        const validationFunction = this.type.validationFunction.extract()?.unannotatedUsage;
         let rhs;
         if (conversionFunction && validationFunction) {
             rhs = code `${conversionFunction}(${parameterVariable}, ${defaultNamespaceVariable}).chain(value => ${validationFunction}(${this.typeSchemaVariable}, value))`;
@@ -165,18 +156,16 @@ export class ObjectType_ShaclProperty extends ObjectType_AbstractProperty {
     }
     equalsExpression({ variables, }) {
         return Maybe.of(code `${this.reusables.snippets.propertyEquals}(
-        { equalsFunction: ${this.type.equalsFunction}, name: ${literalOf(this.name)} },
+        { equalsFunction: ${this.type.equalsFunction.unannotatedUsage}, name: ${literalOf(this.name)} },
         [left, ${variables.leftObject}.${this.name}],
         [right, ${variables.rightObject}.${this.name}],
       )`);
     }
     filterExpression({ variables, }) {
-        return Maybe.of(code `${this.type.filterFunction}(${variables.filter}.${this.name}, ${variables.object}.${this.name})`);
+        return Maybe.of(code `${this.type.filterFunction.unannotatedUsage}(${variables.filter}.${this.name}, ${variables.object}.${this.name})`);
     }
-    fromJsonInitializer({ variables, }) {
-        return Maybe.of(code `${this.name}: ${this.type.fromJsonExpression({
-            variables: { value: code `${variables.jsonObject}["${this.name}"]` },
-        })}`);
+    fromJsonObjectInitializer({ variables, }) {
+        return Maybe.of(code `${this.name}: (${this.type.fromJsonValueFunction.unannotatedUsage})(${variables.jsonObject}["${this.name}"], { ...${variables.options}, schema: ${this.typeSchemaVariable} })`);
     }
     fromRdfResourceValuesInitializer({ variables, }) {
         return Maybe.of(code `${this.name}:
@@ -185,20 +174,14 @@ export class ObjectType_ShaclProperty extends ObjectType_AbstractProperty {
           focusResource: ${variables.focusResource},
           ignoreRdfType: true,
           propertySchema: ${this.schemaVariable},
-          typeFromRdfResourceValues: ${this.type.fromRdfResourceValuesFunction} 
+          typeFromRdfResourceValues: ${this.type.fromRdfResourceValuesFunction.unannotatedUsage} 
         })`);
     }
     hashStatements({ variables, }) {
         return [
-            code `${this.type.hashFunction}(${variables.hasher}, ${variables.object}.${this.name});`,
+            code `${this.type.hashFunction.annotatedUsage}(${variables.hasher}, ${variables.object}.${this.name});`,
         ];
     }
-    jsonUiSchemaElement({ variables, }) {
-        const scope = code `\`\${${variables.scopePrefix}}/properties/${this.name}\``;
-        return this.type
-            .jsonUiSchemaElement({ variables: { scopePrefix: scope } })
-            .altLazy(() => Maybe.of(code `{ ${this.label.isJust() ? `label: "${this.label.unsafeCoerce()}", ` : ""}scope: ${scope}, type: "Control" }`));
-    }
     sparqlConstructTriplesExpression({ variables, }) {
         return Maybe.of(code `${this.reusables.snippets.shaclPropertySparqlConstructTriples}(${{
             filter: this.filterProperty
@@ -208,7 +191,7 @@ export class ObjectType_ShaclProperty extends ObjectType_AbstractProperty {
             ignoreRdfType: true,
             propertyName: this.name,
             propertySchema: this.schemaVariable,
-            typeSparqlConstructTriples: this.type.valueSparqlConstructTriplesFunction,
+            typeSparqlConstructTriples: this.type.valueSparqlConstructTriplesFunction.unannotatedUsage,
             variablePrefix: variables.variablePrefix,
         }})`);
     }
@@ -223,15 +206,19 @@ export class ObjectType_ShaclProperty extends ObjectType_AbstractProperty {
                 preferredLanguages: variables.preferredLanguages,
                 propertyName: this.name,
                 propertySchema: this.schemaVariable,
-                typeSparqlWherePatterns: this.type.valueSparqlWherePatternsFunction,
+                typeSparqlWherePatterns: this.type.valueSparqlWherePatternsFunction.unannotatedUsage,
                 variablePrefix: variables.variablePrefix,
             }})`,
         });
     }
-    toJsonInitializer({ variables, }) {
-        return Maybe.of(code `${this.name}: ${this.type.toJsonExpression({ variables: { value: code `${variables.object}.${this.name}` } })}`);
+    toJsonObjectInitializer({ variables, }) {
+        return Maybe.of(code `${this.name}: (${this.type.toJsonValueFunction.unannotatedUsage})(${variables.object}.${this.name})`);
+    }
+    toLoggableInitializer({ variables, }) {
+        const { object: objectVariable, ...otherVariables } = variables;
+        return Maybe.of(code `${literalOf(this.name)}: ${this.type.toLoggableExpression({ variables: { ...otherVariables, value: code `${objectVariable}.${this.name}` } })}`);
     }
-    toRdfRdfResourceValuesStatements({ variables, }) {
+    toRdfResourceValuesStatements({ variables, }) {
         switch (this.path.termType) {
             case "NamedNode":
                 break;
@@ -281,7 +268,7 @@ export class ObjectType_ShaclProperty extends ObjectType_AbstractProperty {
 }
 __decorate([
     Memoize()
-], ObjectType_ShaclProperty.prototype, "constructorParameter", null);
+], ObjectType_ShaclProperty.prototype, "createFunctionParameter", null);
 __decorate([
     Memoize()
 ], ObjectType_ShaclProperty.prototype, "declaration", null);
@@ -293,11 +280,8 @@ __decorate([
 ], ObjectType_ShaclProperty.prototype, "graphqlField", null);
 __decorate([
     Memoize()
-], ObjectType_ShaclProperty.prototype, "jsonSchema", null);
-__decorate([
-    Memoize()
-], ObjectType_ShaclProperty.prototype, "jsonSignature", null);
+], ObjectType_ShaclProperty.prototype, "jsonObjectMember", null);
 __decorate([
     Memoize()
-], ObjectType_ShaclProperty.prototype, "schemaVariable", null);
+], ObjectType_ShaclProperty.prototype, "typeSchemaVariable", null);
 //# sourceMappingURL=ObjectType_ShaclProperty.js.map

package/dist/generators/ts/_ObjectType/ObjectType__fromRdfResourceFunction.d.ts

@@ -0,0 +1,4 @@
+import type { Callable } from "../Callable.js";
+import type { ObjectType } from "../ObjectType.js";
+export declare function ObjectType__fromRdfResourceFunction(this: ObjectType): Callable;
+//# sourceMappingURL=ObjectType__fromRdfResourceFunction.d.ts.map

package/dist/generators/ts/_ObjectType/{ObjectType_fromRdfResourceFunctionExpression.js → ObjectType__fromRdfResourceFunction.js}

@@ -1,6 +1,6 @@
 import { invariant } from "ts-invariant";
-import { arrayOf, code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectType_fromRdfResourceFunctionExpression() {
+import { code, joinCode } from "../ts-poet-wrapper.js";
+function ObjectType__fromRdfResourceFunctionExpression() {
     const optionsVariable = code `options`;
     const variables = {
         context: code `${optionsVariable}.context`,
@@ -11,16 +11,12 @@ export function ObjectType_fromRdfResourceFunctionExpression() {
         resource: code `resource`,
     };
     const chains = [];
-    this.fromRdfTypeVariable.ifJust((fromRdfTypeVariable) => {
-        chains.push({
-            expression: code `!${variables.ignoreRdfType} ? ${this.reusables.snippets.ensureRdfResourceType}(${variables.resource}, ${arrayOf(fromRdfTypeVariable)}, ${{ graph: variables.graph }}) : ${this.reusables.imports.Right}(true as const)`,
-            variable: `_rdfTypeCheck`,
-        });
-    });
     const propertyFromRdfResourceValuesInitializers = this.properties.flatMap((property) => property
         .fromRdfResourceValuesInitializer({
         variables: {
             focusResource: variables.resource,
+            graph: variables.graph,
+            ignoreRdfType: variables.ignoreRdfType,
             options: optionsVariable,
         },
     })
@@ -31,8 +27,15 @@ export function ObjectType_fromRdfResourceFunctionExpression() {
         variable: "properties",
     });
     return code `\
-((${variables.resource}, ${optionsVariable}) => ${chains
+(${variables.resource}, ${optionsVariable}) => ${chains
         .reverse()
-        .reduce((acc, { expression, variable }) => code `(${expression}).chain(${variable} => ${acc})`, code `(${this.createFunction}(properties))`)})`;
+        .reduce((acc, { expression, variable }) => code `(${expression}).chain(${variable} => ${acc})`, code `(${this.createFunction.annotatedUsage}(properties))`)}`;
+}
+export function ObjectType__fromRdfResourceFunction() {
+    return this._function({
+        type: code `${this.reusables.snippets._FromRdfResourceFunction}<${this.discriminatedType.map((discriminatedType) => discriminatedType.expression).orDefault(this.expression)}>`,
+        unannotatedExpression: () => ObjectType__fromRdfResourceFunctionExpression.call(this),
+        unqualifiedName: "_fromRdfResource",
+    });
 }
-//# sourceMappingURL=ObjectType_fromRdfResourceFunctionExpression.js.map
+//# sourceMappingURL=ObjectType__fromRdfResourceFunction.js.map

package/dist/generators/ts/_ObjectType/ObjectType__toRdfResourceFunction.d.ts

@@ -0,0 +1,4 @@
+import type { Callable } from "../Callable.js";
+import type { ObjectType } from "../ObjectType.js";
+export declare function ObjectType__toRdfResourceFunction(this: ObjectType): Callable;
+//# sourceMappingURL=ObjectType__toRdfResourceFunction.d.ts.map

package/dist/generators/ts/_ObjectType/ObjectType__toRdfResourceFunction.js

@@ -0,0 +1,32 @@
+import { code, joinCode } from "../ts-poet-wrapper.js";
+function ObjectType__toRdfResourceFunctionExpression() {
+    const statements = [];
+    const variables = {
+        ignoreRdfType: code `parameters.ignoreRdfType`,
+        graph: code `parameters.graph`,
+        object: code `parameters.object`,
+        resource: code `parameters.resource`,
+        resourceSet: code `parameters.resourceSet`,
+    };
+    for (const property of this.properties) {
+        statements.push(...property.toRdfResourceValuesStatements({
+            variables,
+        }));
+    }
+    statements.push(code `return ${variables.resource};`);
+    return code `\
+(parameters) => {
+  ${joinCode(statements)}
+}`;
+}
+export function ObjectType__toRdfResourceFunction() {
+    const identifierTypeExpression = this.name
+        .map(() => this.identifierTypeAlias)
+        .orDefault(this.identifierType.expression);
+    return this._function({
+        type: code `${this.reusables.snippets._ToRdfResourceFunction}<${identifierTypeExpression}, ${this.expression}>`,
+        unannotatedExpression: () => ObjectType__toRdfResourceFunctionExpression.call(this),
+        unqualifiedName: "_toRdfResource",
+    });
+}
+//# sourceMappingURL=ObjectType__toRdfResourceFunction.js.map

package/dist/generators/ts/_ObjectType/ObjectType_conversionFunction.d.ts

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import type { AbstractType_ConversionFunction } from "../_AbstractType/AbstractType_ConversionFunction.js";
+import type { ObjectType } from "../ObjectType.js";
+export declare function ObjectType_conversionFunction(this: ObjectType): Maybe<AbstractType_ConversionFunction>;
+//# sourceMappingURL=ObjectType_conversionFunction.d.ts.map

package/dist/generators/ts/_ObjectType/ObjectType_conversionFunction.js

@@ -0,0 +1,28 @@
+import { Maybe } from "purify-ts";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectType_conversionFunction() {
+    if (this.name.isJust()) {
+        return Maybe.empty();
+    }
+    const sourceTypePropertySignatures = [];
+    for (const property of this.properties) {
+        property.createFunctionParameter.ifJust((propertyConstructorParameter) => {
+            sourceTypePropertySignatures.push(propertyConstructorParameter.signature);
+        });
+    }
+    const sourceTypeExpression = code `{ ${joinCode(sourceTypePropertySignatures)} }`;
+    const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
+    return Maybe.of({
+        code: code `(<${syntheticNamePrefix}DefaultNamespaceT extends ${this.reusables.snippets.NamespaceBuilder} = ${this.reusables.snippets.NamespaceBuilder}>(value: ${sourceTypeExpression}, ${syntheticNamePrefix}defaultNamespace?: ${syntheticNamePrefix}DefaultNamespaceT) => ${this.createFunction.unannotatedUsage}({ ...value, ${syntheticNamePrefix}defaultNamespace }))`,
+        sourceTypes: [
+            {
+                expression: sourceTypeExpression,
+                jsType: {
+                    instanceof: "Object",
+                    typeof: "object",
+                },
+            },
+        ],
+    });
+}
+//# sourceMappingURL=ObjectType_conversionFunction.js.map

package/dist/generators/ts/_ObjectType/ObjectType_createFunction.d.ts

@@ -0,0 +1,4 @@
+import type { Callable } from "../Callable.js";
+import type { ObjectType } from "../ObjectType.js";
+export declare function ObjectType_createFunction(this: ObjectType): Callable;
+//# sourceMappingURL=ObjectType_createFunction.d.ts.map

package/dist/generators/ts/_ObjectType/ObjectType_createFunction.js

@@ -0,0 +1,31 @@
+import { invariant } from "ts-invariant";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+function ObjectType_createFunctionExpression() {
+    const propertyInitializers = this.properties.flatMap((property) => property
+        .createInitializer({
+        variables: { parameters: this.createFunctionParameters.variable },
+    })
+        .toList());
+    invariant(propertyInitializers.length > 0);
+    let returnExpression = code `${this.reusables.snippets.sequenceRecord}({ ${joinCode(propertyInitializers, { on: "," })} })`;
+    const monkeyPatchMethods = {};
+    if (this.configuration.features.has("Object.toJson")) {
+        monkeyPatchMethods["toJson"] = this.toJsonObjectFunction.annotatedUsage;
+    }
+    if (this.configuration.features.has("Object.toString")) {
+        monkeyPatchMethods[`${this.configuration.syntheticNamePrefix}toString`] =
+            this.toStringFunction.annotatedUsage;
+    }
+    if (Object.keys(monkeyPatchMethods).length > 0) {
+        returnExpression = code `${returnExpression}.map(object => ${this.reusables.snippets.monkeyPatchObject}(object, ${monkeyPatchMethods}))`;
+    }
+    return code `(${this.createFunctionParameters.variable}${this.createFunctionParameters.hasQuestionToken ? code ` = {}` : code ``}) => ${returnExpression}`;
+}
+export function ObjectType_createFunction() {
+    return this._function({
+        type: code `<${this.configuration.syntheticNamePrefix}DefaultNamespaceT extends ${this.reusables.snippets.NamespaceBuilder} = ${this.reusables.snippets.NamespaceBuilder}>(${this.createFunctionParameters.signature}) => ${this.reusables.imports.Either}<Error, ${this.discriminatedType.map((discriminatedType) => discriminatedType.expression).orDefault(this.expression)}>`,
+        unannotatedExpression: () => ObjectType_createFunctionExpression.call(this),
+        unqualifiedName: "create",
+    });
+}
+//# sourceMappingURL=ObjectType_createFunction.js.map

package/dist/generators/ts/_ObjectType/ObjectType_createFunctionParameters.d.ts

@@ -0,0 +1,3 @@
+import type { ObjectType } from "../ObjectType.js";
+export declare function ObjectType_createFunctionParameters(this: ObjectType): ObjectType.CreateFunctionParameters;
+//# sourceMappingURL=ObjectType_createFunctionParameters.d.ts.map

package/dist/generators/ts/_ObjectType/ObjectType_createFunctionParameters.js

@@ -0,0 +1,29 @@
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectType_createFunctionParameters() {
+    let hasQuestionToken = true;
+    const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
+    const propertySignatures = [
+        code `readonly ${syntheticNamePrefix}defaultNamespace?: ${syntheticNamePrefix}DefaultNamespaceT;`,
+    ];
+    for (const property of this.properties) {
+        property.createFunctionParameter.ifJust((propertyConstructorParameter) => {
+            hasQuestionToken =
+                hasQuestionToken && propertyConstructorParameter.hasQuestionToken;
+            propertySignatures.push(propertyConstructorParameter.signature);
+        });
+    }
+    const typeInlineExpression = code `{ ${joinCode(propertySignatures)} }`;
+    const type = {
+        expression: this.name
+            .map((name) => code `${name}.CreateParameters<${syntheticNamePrefix}DefaultNamespaceT>`)
+            .orDefault(typeInlineExpression),
+        inlineExpression: typeInlineExpression,
+    };
+    return {
+        hasQuestionToken,
+        signature: code `parameters${hasQuestionToken ? "?" : ""}: ${type.expression}`,
+        type,
+        variable: code `parameters`,
+    };
+}
+//# sourceMappingURL=ObjectType_createFunctionParameters.js.map

package/dist/generators/ts/_ObjectType/ObjectType_createUnsafeFunction.d.ts

@@ -0,0 +1,4 @@
+import type { Callable } from "../Callable.js";
+import type { ObjectType } from "../ObjectType.js";
+export declare function ObjectType_createUnsafeFunction(this: ObjectType): Callable;
+//# sourceMappingURL=ObjectType_createUnsafeFunction.d.ts.map

package/dist/generators/ts/_ObjectType/ObjectType_createUnsafeFunction.js

@@ -0,0 +1,10 @@
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectType_createUnsafeFunction() {
+    const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
+    return this._function({
+        type: code `<${syntheticNamePrefix}DefaultNamespaceT extends ${this.reusables.snippets.NamespaceBuilder} = ${this.reusables.snippets.NamespaceBuilder}>(${this.createFunctionParameters.signature}) => ${this.discriminatedType.map((discriminatedType) => discriminatedType.expression).orDefault(this.expression)}`,
+        unannotatedExpression: () => code `(${this.createFunctionParameters.variable}) => create(${this.createFunctionParameters.variable}).unsafeCoerce()`,
+        unqualifiedName: "createUnsafe",
+    });
+}
+//# sourceMappingURL=ObjectType_createUnsafeFunction.js.map

package/dist/generators/ts/_ObjectType/{ObjectType_equalsFunctionExpression.d.ts → ObjectType_equalsFunction.d.ts}

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

package/dist/generators/ts/_ObjectType/{ObjectType_equalsFunctionExpression.js → ObjectType_equalsFunction.js}

@@ -9,8 +9,10 @@ export function ObjectType_equalsFunctionExpression() {
         chain.push(...property.equalsExpression({ variables }).toList());
     }
     return code `\
-((left, right) =>
-  ${joinCode(chain.map((chainPart, chainPartI) => chainPartI === 0 ? chainPart : code `chain(() => ${chainPart})`), { on: "." })}
-)`;
+(left, right) =>
+  ${joinCode(chain.map((chainPart, chainPartI) => chainPartI === 0 ? chainPart : code `chain(() => ${chainPart})`), { on: "." })}`;
 }
-//# sourceMappingURL=ObjectType_equalsFunctionExpression.js.map
+export function ObjectType_equalsFunctionType() {
+    return code `${this.reusables.snippets.EqualsFunction}<${this.propertySubsetExpression((property) => property.equalsExpression({ variables }).isJust())}>`;
+}
+//# sourceMappingURL=ObjectType_equalsFunction.js.map

package/dist/generators/ts/_ObjectType/{ObjectType_filterFunctionExpression.d.ts → ObjectType_filterFunction.d.ts}

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

package/dist/generators/ts/_ObjectType/{ObjectType_filterFunctionExpression.js → ObjectType_filterFunction.js}

@@ -16,6 +16,9 @@ export function ObjectType_filterFunctionExpression() {
         });
     }
     statements.push(code `return true;`);
-    return code `((filter, value) => { ${joinCode(statements)} })`;
+    return code `(filter, value) => { ${joinCode(statements)} }`;
 }
-//# sourceMappingURL=ObjectType_filterFunctionExpression.js.map
+export function ObjectType_filterFunctionType() {
+    return code `${this.reusables.snippets.FilterFunction}<${this.filterType}, ${this.propertySubsetExpression((property) => property.filterProperty.isJust())}>`;
+}
+//# sourceMappingURL=ObjectType_filterFunction.js.map

package/dist/generators/ts/_ObjectType/{ObjectType_focusSparqlConstructTriplesFunctionExpression.d.ts → ObjectType_focusSparqlConstructTriplesFunction.d.ts}

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

package/dist/generators/ts/_ObjectType/{ObjectType_focusSparqlConstructTriplesFunctionExpression.js → ObjectType_focusSparqlConstructTriplesFunction.js}

@@ -5,7 +5,7 @@ const variables = {
     ignoreRdfType: code `parameters.ignoreRdfType`,
     variablePrefix: code `parameters.variablePrefix`,
 };
-export function ObjectType_focusSparqlConstructTriplesFunctionExpression() {
+function ObjectType_focusSparqlConstructTriplesFunctionExpression() {
     let triplesVariableDeclarationKeyword = "const";
     const statements = [];
     for (const property of this.properties) {
@@ -22,7 +22,7 @@ export function ObjectType_focusSparqlConstructTriplesFunctionExpression() {
         });
     }
     return code `\
-((${statements.length === 0 ? "_" : ""}parameters) => {
+(${statements.length === 0 ? "_" : ""}parameters) => {
 ${statements.length > 0
         ? joinCode([
             code `${triplesVariableDeclarationKeyword} triples: ${this.reusables.imports.sparqljs}.Triple[] = [];`,
@@ -30,6 +30,13 @@ ${statements.length > 0
             code `return triples;`,
         ])
         : "return [];"}
-})`;
+}`;
 }
-//# sourceMappingURL=ObjectType_focusSparqlConstructTriplesFunctionExpression.js.map
+export function ObjectType_focusSparqlConstructTriplesFunction() {
+    return this._function({
+        type: code `${this.reusables.snippets.FocusSparqlConstructTriplesFunction}<${this.filterType}>`,
+        unannotatedExpression: () => ObjectType_focusSparqlConstructTriplesFunctionExpression.call(this),
+        unqualifiedName: "focusSparqlConstructTriples",
+    });
+}
+//# sourceMappingURL=ObjectType_focusSparqlConstructTriplesFunction.js.map

package/dist/generators/ts/_ObjectType/{ObjectType_focusSparqlWherePatternsFunctionExpression.d.ts → ObjectType_focusSparqlWherePatternsFunction.d.ts}

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

package/dist/generators/ts/_ObjectType/{ObjectType_focusSparqlWherePatternsFunctionExpression.js → ObjectType_focusSparqlWherePatternsFunction.js}

@@ -1,5 +1,5 @@
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectType_focusSparqlWherePatternsFunctionExpression() {
+function ObjectType_focusSparqlWherePatternsFunctionExpression() {
     let patternsVariableDeclarationKeyword = "const";
     const statements = [];
     const variables = {
@@ -28,7 +28,7 @@ export function ObjectType_focusSparqlWherePatternsFunctionExpression() {
         });
     }
     return code `\
-((${statements.length === 0 ? "_" : ""}parameters) => {
+(${statements.length === 0 ? "_" : ""}parameters) => {
 ${statements.length > 0
         ? joinCode([
             code `${patternsVariableDeclarationKeyword} patterns: ${this.reusables.snippets.SparqlPattern}[] = [];`,
@@ -36,6 +36,13 @@ ${statements.length > 0
             code `return patterns;`,
         ])
         : "return [];"}
-})`;
+}`;
 }
-//# sourceMappingURL=ObjectType_focusSparqlWherePatternsFunctionExpression.js.map
+export function ObjectType_focusSparqlWherePatternsFunction() {
+    return this._function({
+        type: code `${this.reusables.snippets.FocusSparqlWherePatternsFunction}<${this.filterType}>`,
+        unannotatedExpression: () => ObjectType_focusSparqlWherePatternsFunctionExpression.call(this),
+        unqualifiedName: "focusSparqlWherePatterns",
+    });
+}
+//# sourceMappingURL=ObjectType_focusSparqlWherePatternsFunction.js.map

package/dist/generators/ts/_ObjectType/ObjectType_fromJsonObjectFunction.d.ts

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

package/dist/generators/ts/_ObjectType/ObjectType_fromJsonObjectFunction.js

@@ -0,0 +1,19 @@
+import { invariant } from "ts-invariant";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectType_fromJsonObjectFunctionExpression() {
+    const optionsVariable = code `options`;
+    const variables = {
+        context: code `${optionsVariable}.context`,
+        jsonObject: code `jsonObject`,
+        objectSet: code `${optionsVariable}.objectSet`,
+        options: optionsVariable,
+    };
+    const propertyInitializers = this.properties.flatMap((property) => property.fromJsonObjectInitializer({ variables }).toList());
+    invariant(propertyInitializers.length > 0);
+    return code `\
+(${variables.jsonObject}, ${variables.options} = {}) => ${this.reusables.snippets.sequenceRecord}({ ${joinCode(propertyInitializers, { on: "," })} }).chain(${this.createFunction.annotatedUsage})`;
+}
+export function ObjectType_fromJsonObjectFunctionType() {
+    return code `${this.reusables.snippets.FromJsonObjectFunction}<${this.jsonObjectType.expression}, ${this.discriminatedType.map((discriminatedType) => discriminatedType.expression).orDefault(this.expression)}, undefined>`;
+}
+//# sourceMappingURL=ObjectType_fromJsonObjectFunction.js.map

package/dist/generators/ts/_ObjectType/ObjectType_fromRdfResourceFunction.d.ts

@@ -0,0 +1,4 @@
+import type { Callable } from "../Callable.js";
+import type { ObjectType } from "../ObjectType.js";
+export declare function ObjectType_fromRdfResourceFunction(this: ObjectType): Callable;
+//# sourceMappingURL=ObjectType_fromRdfResourceFunction.d.ts.map

package/dist/generators/ts/_ObjectType/ObjectType_fromRdfResourceFunction.js

@@ -0,0 +1,9 @@
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectType_fromRdfResourceFunction() {
+    return this._function({
+        type: code `${this.reusables.snippets.FromRdfResourceFunction}<${this.discriminatedType.map((discriminatedType) => discriminatedType.expression).orDefault(this.expression)}>`,
+        unannotatedExpression: () => code `${this.reusables.snippets.wrap_FromRdfResourceFunction}(${this._fromRdfResourceFunction.annotatedUsage})`,
+        unqualifiedName: "fromRdfResource",
+    });
+}
+//# sourceMappingURL=ObjectType_fromRdfResourceFunction.js.map

package/dist/generators/ts/_ObjectType/ObjectType_fromRdfResourceValuesFunction.d.ts

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

package/dist/generators/ts/_ObjectType/ObjectType_fromRdfResourceValuesFunction.js

@@ -0,0 +1,8 @@
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectType_fromRdfResourceValuesFunctionExpression() {
+    return code `(values, options) => values.chainMap(value => value.toResource().chain(resource => ${this.fromRdfResourceFunction.annotatedUsage}(resource, options)))`;
+}
+export function ObjectType_fromRdfResourceValuesFunctionType() {
+    return code `${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.discriminatedType.map((discriminatedType) => discriminatedType.expression).orDefault(this.expression)}, ${this.schemaType}>`;
+}
+//# sourceMappingURL=ObjectType_fromRdfResourceValuesFunction.js.map

package/dist/generators/ts/_ObjectType/{ObjectType_hashFunctionExpression.d.ts → ObjectType_hashFunction.d.ts}

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