@shaclmate/compiler 4.0.93 → 4.0.95

package/dist/generators/ts/ObjectType.js

@@ -9,56 +9,90 @@ import { camelCase } from "change-case";
 import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
-import { ObjectType_createFunctionExpression } from "./_ObjectType/ObjectType_createFunctionExpression.js";
+import { ObjectType__fromRdfResourceFunction } from "./_ObjectType/ObjectType__fromRdfResourceFunction.js";
+import { ObjectType__toRdfResourceFunction } from "./_ObjectType/ObjectType__toRdfResourceFunction.js";
+import { ObjectType_conversionFunction } from "./_ObjectType/ObjectType_conversionFunction.js";
+import { ObjectType_createFunction } from "./_ObjectType/ObjectType_createFunction.js";
+import { ObjectType_createFunctionParameters } from "./_ObjectType/ObjectType_createFunctionParameters.js";
+import { ObjectType_createUnsafeFunction } from "./_ObjectType/ObjectType_createUnsafeFunction.js";
 import { ObjectType_DiscriminantProperty } from "./_ObjectType/ObjectType_DiscriminantProperty.js";
-import { ObjectType_equalsFunctionExpression } from "./_ObjectType/ObjectType_equalsFunctionExpression.js";
-import { ObjectType_filterFunctionExpression } from "./_ObjectType/ObjectType_filterFunctionExpression.js";
+import { ObjectType_equalsFunctionExpression, ObjectType_equalsFunctionType, } from "./_ObjectType/ObjectType_equalsFunction.js";
+import { ObjectType_filterFunctionExpression, ObjectType_filterFunctionType, } from "./_ObjectType/ObjectType_filterFunction.js";
 import { ObjectType_filterTypeExpression } from "./_ObjectType/ObjectType_filterTypeExpression.js";
-import { ObjectType_focusSparqlConstructTriplesFunctionExpression } from "./_ObjectType/ObjectType_focusSparqlConstructTriplesFunctionExpression.js";
-import { ObjectType_focusSparqlWherePatternsFunctionExpression } from "./_ObjectType/ObjectType_focusSparqlWherePatternsFunctionExpression.js";
-import { ObjectType_fromJsonFunctionExpression } from "./_ObjectType/ObjectType_fromJsonFunctionExpression.js";
-import { ObjectType_fromRdfResourceFunctionExpression } from "./_ObjectType/ObjectType_fromRdfResourceFunctionExpression.js";
+import { ObjectType_focusSparqlConstructTriplesFunction } from "./_ObjectType/ObjectType_focusSparqlConstructTriplesFunction.js";
+import { ObjectType_focusSparqlWherePatternsFunction } from "./_ObjectType/ObjectType_focusSparqlWherePatternsFunction.js";
+import { ObjectType_fromJsonObjectFunctionExpression, ObjectType_fromJsonObjectFunctionType, } from "./_ObjectType/ObjectType_fromJsonObjectFunction.js";
+import { ObjectType_fromRdfResourceFunction } from "./_ObjectType/ObjectType_fromRdfResourceFunction.js";
+import { ObjectType_fromRdfResourceValuesFunctionExpression, ObjectType_fromRdfResourceValuesFunctionType, } from "./_ObjectType/ObjectType_fromRdfResourceValuesFunction.js";
 import { ObjectType_graphqlTypeExpression } from "./_ObjectType/ObjectType_graphqlTypeExpression.js";
-import { ObjectType_hashFunctionExpression } from "./_ObjectType/ObjectType_hashFunctionExpression.js";
+import { ObjectType_hashFunctionExpression, ObjectType_hashFunctionType, } from "./_ObjectType/ObjectType_hashFunction.js";
 import { ObjectType_IdentifierProperty } from "./_ObjectType/ObjectType_IdentifierProperty.js";
 import { ObjectType_identifierTypeDeclarations } from "./_ObjectType/ObjectType_identifierTypeDeclarations.js";
-import { ObjectType_jsonParseFunctionDeclaration } from "./_ObjectType/ObjectType_jsonParseFunctionDeclaration.js";
-import { ObjectType_jsonSchemaExpression } from "./_ObjectType/ObjectType_jsonSchemaExpression.js";
-import { ObjectType_jsonTypeExpression } from "./_ObjectType/ObjectType_jsonTypeExpression.js";
-import { ObjectType_jsonUiSchemaFunctionExpression } from "./_ObjectType/ObjectType_jsonUiSchemaFunctionExpression.js";
 import { ObjectType_objectSetMethodNames } from "./_ObjectType/ObjectType_objectSetMethodNames.js";
 import { ObjectType_RdfTypeProperty } from "./_ObjectType/ObjectType_RdfTypeProperty.js";
 import { ObjectType_ShaclProperty } from "./_ObjectType/ObjectType_ShaclProperty.js";
 import { ObjectType_schemaExpression } from "./_ObjectType/ObjectType_schemaExpression.js";
 import { ObjectType_schemaTypeExpression } from "./_ObjectType/ObjectType_schemaTypeExpression.js";
-import { ObjectType_sparqlConstructQueryFunctionDeclaration } from "./_ObjectType/ObjectType_sparqlConstructQueryFunctionDeclaration.js";
-import { ObjectType_sparqlConstructQueryStringFunctionDeclaration } from "./_ObjectType/ObjectType_sparqlConstructQueryStringFunctionDeclaration.js";
-import { ObjectType_toJsonFunctionExpression } from "./_ObjectType/ObjectType_toJsonFunctionExpression.js";
-import { ObjectType_toRdfResourceFunctionExpression } from "./_ObjectType/ObjectType_toRdfResourceFunctionExpression.js";
-import { ObjectType_toStringFunctionExpression } from "./_ObjectType/ObjectType_toStringFunctionExpression.js";
-import { ObjectType_toStringRecordFunctionExpression } from "./_ObjectType/ObjectType_toStringRecordFunctionExpression.js";
-import { ObjectType_typeGuardFunctionExpression } from "./_ObjectType/ObjectType_typeGuardFunctionExpression.js";
-import { ObjectType_valueSparqlConstructTriplesFunctionExpression } from "./_ObjectType/ObjectType_valueSparqlConstructTriplesFunctionExpression.js";
-import { ObjectType_valueSparqlWherePatternsFunctionExpression } from "./_ObjectType/ObjectType_valueSparqlWherePatternsFunctionExpression.js";
-import { AbstractType } from "./AbstractType.js";
-import { arrayOf, code, joinCode } from "./ts-poet-wrapper.js";
-export class ObjectType extends AbstractType {
-    discriminantProperty;
+import { ObjectType_sparqlConstructQueryFunction } from "./_ObjectType/ObjectType_sparqlConstructQueryFunction.js";
+import { ObjectType_sparqlConstructQueryStringFunction } from "./_ObjectType/ObjectType_sparqlConstructQueryStringFunction.js";
+import { ObjectType_toJsonObjectFunctionExpression, ObjectType_toJsonObjectFunctionType, } from "./_ObjectType/ObjectType_toJsonObjectFunction.js";
+import { ObjectType_toLoggableFunctionExpression, ObjectType_toLoggableFunctionType, } from "./_ObjectType/ObjectType_toLoggableFunction.js";
+import { ObjectType_toRdfResourceFunction } from "./_ObjectType/ObjectType_toRdfResourceFunction.js";
+import { ObjectType_toRdfResourceValuesFunctionExpression, ObjectType_toRdfResourceValuesFunctionType, } from "./_ObjectType/ObjectType_toRdfResourceValuesFunction.js";
+import { ObjectType_toStringFunctionExpression, ObjectType_toStringFunctionType, } from "./_ObjectType/ObjectType_toStringFunction.js";
+import { ObjectType_toStringRecordFunction } from "./_ObjectType/ObjectType_toStringRecordFunction.js";
+import { ObjectType_typeGuardFunction } from "./_ObjectType/ObjectType_typeGuardFunction.js";
+import { ObjectType_valueSparqlConstructTriplesFunctionExpression } from "./_ObjectType/ObjectType_valueSparqlConstructTriplesFunction.js";
+import { ObjectType_valueSparqlWherePatternsFunctionExpression } from "./_ObjectType/ObjectType_valueSparqlWherePatternsFunction.js";
+import { AbstractStructuredType } from "./AbstractStructuredType.js";
+import { DeclaredCallable } from "./DeclaredCallable.js";
+import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
+export class ObjectType extends AbstractStructuredType {
+    rdfTypeProperty;
+    equalsFunctionExpression = ObjectType_equalsFunctionExpression;
+    equalsFunctionType = ObjectType_equalsFunctionType;
+    filterFunctionExpression = ObjectType_filterFunctionExpression;
+    filterFunctionType = ObjectType_filterFunctionType;
+    filterTypeExpression = ObjectType_filterTypeExpression;
+    fromJsonObjectFunctionExpression = ObjectType_fromJsonObjectFunctionExpression;
+    fromJsonObjectFunctionType = ObjectType_fromJsonObjectFunctionType;
+    fromRdfResourceValuesFunctionExpression = ObjectType_fromRdfResourceValuesFunctionExpression;
+    fromRdfResourceValuesFunctionType = ObjectType_fromRdfResourceValuesFunctionType;
+    hashFunctionExpression = ObjectType_hashFunctionExpression;
+    hashFunctionType = ObjectType_hashFunctionType;
+    schemaExpression = ObjectType_schemaExpression;
+    schemaTypeExpression = ObjectType_schemaTypeExpression;
+    toJsonObjectFunctionExpression = ObjectType_toJsonObjectFunctionExpression;
+    toJsonObjectFunctionType = ObjectType_toJsonObjectFunctionType;
+    toLoggableFunctionExpression = ObjectType_toLoggableFunctionExpression;
+    toLoggableFunctionType = ObjectType_toLoggableFunctionType;
+    toRdfResourceValuesFunctionExpression = ObjectType_toRdfResourceValuesFunctionExpression;
+    toRdfResourceValuesFunctionType = ObjectType_toRdfResourceValuesFunctionType;
+    toStringFunctionExpression = ObjectType_toStringFunctionExpression;
+    toStringFunctionType = ObjectType_toStringFunctionType;
+    valueSparqlConstructTriplesFunctionExpression = ObjectType_valueSparqlConstructTriplesFunctionExpression;
+    valueSparqlWherePatternsFunctionExpression = ObjectType_valueSparqlWherePatternsFunctionExpression;
+    discriminatedType;
     extern;
     graphqlArgs = Maybe.empty();
+    identifierProperty;
     identifierType;
     jsTypes = [
         { instanceof: "Object", typeof: "object" },
     ];
     kind = "Object";
-    rdfTypeProperty;
     recursive;
     synthetic;
     validationFunction = Maybe.empty();
-    constructor({ discriminantProperty, extern, identifierType, lazyProperties, rdfTypeProperty, recursive, synthetic, ...superParameters }) {
+    constructor({ discriminantProperty, extern, identifierProperty, identifierType, lazyProperties, rdfTypeProperty, recursive, synthetic, ...superParameters }) {
         super(superParameters);
-        this.discriminantProperty = discriminantProperty;
+        this.discriminatedType = discriminantProperty.map((discriminantProperty) => ({
+            discriminantProperty,
+            // If discriminantProperty is Just then name must be as well.
+            expression: code `${this.name.unsafeCoerce()}.Discriminated`,
+        }));
         this.extern = extern;
+        this.identifierProperty = identifierProperty;
         this.identifierType = identifierType;
         // Lazily initialize some members in getters to avoid recursive construction
         this.lazyProperties = lazyProperties;
@@ -66,197 +100,43 @@ export class ObjectType extends AbstractType {
         this.recursive = recursive;
         this.synthetic = synthetic;
     }
+    get _fromRdfResourceFunction() {
+        return ObjectType__fromRdfResourceFunction.call(this);
+    }
+    get _toRdfResourceFunction() {
+        return ObjectType__toRdfResourceFunction.call(this);
+    }
+    get jsonValueType() {
+        return this.jsonObjectType;
+    }
     get conversionFunction() {
-        if (this.name.isJust()) {
-            return Maybe.empty();
-        }
-        const sourceTypePropertySignatures = [];
-        for (const property of this.properties) {
-            property.constructorParameter.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}({ ...value, ${syntheticNamePrefix}defaultNamespace }))`,
-            sourceTypes: [
-                {
-                    expression: sourceTypeExpression,
-                    jsType: {
-                        instanceof: "Object",
-                        typeof: "object",
-                    },
-                },
-            ],
-        });
+        return ObjectType_conversionFunction.call(this);
     }
-    staticModuleDeclarations(name) {
-        let staticModuleDeclarations = {
-            ...super.staticModuleDeclarations(name),
-        };
-        const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
-        // create
-        if (this.configuration.features.has("Object.create")) {
-            staticModuleDeclarations["create"] =
-                code `export const create = ${ObjectType_createFunctionExpression.call(this)};`;
-            staticModuleDeclarations["createUnsafe"] =
-                code `export function createUnsafe<${syntheticNamePrefix}DefaultNamespaceT extends ${this.reusables.snippets.NamespaceBuilder} = ${this.reusables.snippets.NamespaceBuilder}>(${this.constructorParameters.signature}): ${this.expression} {
-  return create(${this.constructorParameters.variable}).unsafeCoerce();
-}`;
-        }
-        // equals
-        if (this.configuration.features.has("Object.equals")) {
-            staticModuleDeclarations["equals"] =
-                code `export const equals: (left: ${this.expression}, right: ${this.expression}) => ${this.reusables.snippets.EqualsResult} = ${ObjectType_equalsFunctionExpression.call(this)};`;
-        }
-        // Filter / filter
-        if (this.configuration.features.has("Object.filter")) {
-            staticModuleDeclarations["Filter"] =
-                code `export type Filter = ${ObjectType_filterTypeExpression.call(this)};`;
-            staticModuleDeclarations["filter"] =
-                code `export const filter: (filter: ${this.filterType}, value: ${this.expression}) => boolean = ${ObjectType_filterFunctionExpression.call(this)};`;
-        }
-        // GraphQL
-        if (this.configuration.features.has("GraphQL") && !this.synthetic) {
-            staticModuleDeclarations["GraphQL"] =
-                code `export const GraphQL = ${ObjectType_graphqlTypeExpression.call(this)};`;
-        }
-        // focusSparqlConstructTriples / focusSparqlWherePatterns
-        if (this.configuration.features.has("Object.SPARQL")) {
-            staticModuleDeclarations["focusSparqlConstructTriples"] =
-                code `export const focusSparqlConstructTriples: ${this.reusables.snippets.FocusSparqlConstructTriplesFunction}<${this.filterType}> = ${ObjectType_focusSparqlConstructTriplesFunctionExpression.call(this)};`;
-            staticModuleDeclarations["focusSparqlWherePatterns"] =
-                code `export const focusSparqlWherePatterns: ${this.reusables.snippets.FocusSparqlWherePatternsFunction}<${this.filterType}> = ${ObjectType_focusSparqlWherePatternsFunctionExpression.call(this)};`;
-        }
-        // fromJson
-        if (this.configuration.features.has("Object.fromJson")) {
-            staticModuleDeclarations["fromJson"] =
-                code `export const fromJson: (json: ${this.jsonType().expression}) => ${this.reusables.imports.Either}<Error, ${this.expression}> = ${ObjectType_fromJsonFunctionExpression.call(this)};`;
-        }
-        // fromRdfResource / fromRdfResourceValues
-        if (this.configuration.features.has("Object.fromRdf")) {
-            staticModuleDeclarations["_fromRdfResource"] =
-                code `export const _fromRdfResource: ${this.reusables.snippets._FromRdfResourceFunction}<${this.expression}> = ${ObjectType_fromRdfResourceFunctionExpression.call(this)};`;
-            staticModuleDeclarations["fromRdfResource"] =
-                code `export const fromRdfResource = ${this.reusables.snippets.wrap_FromRdfResourceFunction}(_fromRdfResource);`;
-            staticModuleDeclarations["fromRdfResourceValues"] =
-                code `export const fromRdfResourceValues: ${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.expression}, ${this.schemaType}> = 
-  (values, options) => values.chainMap(value => value.toResource().chain(resource => fromRdfResource(resource, options)));`;
-        }
-        // hash
-        if (this.configuration.features.has("Object.hash")) {
-            staticModuleDeclarations["hash"] =
-                code `export const hash = ${ObjectType_hashFunctionExpression.call(this)};`;
-        }
-        // Identifier
-        if (this.configuration.features.has("Object.type")) {
-            staticModuleDeclarations = {
-                ...staticModuleDeclarations,
-                ...ObjectType_identifierTypeDeclarations.call(this),
-            };
-        }
-        // Type guard
-        ObjectType_typeGuardFunctionExpression.call(this).ifJust((typeGuardFunctionExpression) => {
-            staticModuleDeclarations[`is${name}`] =
-                code `export const is${name} = ${typeGuardFunctionExpression};`;
-        });
-        // type Json
-        if (this.configuration.features.has("Object.JSON.type")) {
-            staticModuleDeclarations["JsonType"] =
-                code `export type Json = ${ObjectType_jsonTypeExpression.call(this)}`;
-        }
-        // namespace Json
-        {
-            const jsonModuleDeclarations = [];
-            if (this.configuration.features.has("Object.JSON.parse")) {
-                jsonModuleDeclarations.push(ObjectType_jsonParseFunctionDeclaration.call(this));
-            }
-            if (this.configuration.features.has("Object.JSON.schema")) {
-                jsonModuleDeclarations.push(code `export function schema() { return ${ObjectType_jsonSchemaExpression.call(this)} satisfies ${this.reusables.imports.z}.ZodType<Json>; }`);
-            }
-            if (this.configuration.features.has("Object.JSON.uiSchema")) {
-                jsonModuleDeclarations.push(code `export const uiSchema = ${ObjectType_jsonUiSchemaFunctionExpression.call(this)};`);
-            }
-            if (jsonModuleDeclarations.length > 0) {
-                staticModuleDeclarations["JsonNamespace"] =
-                    code `export namespace Json { ${joinCode(jsonModuleDeclarations, { on: "\n\n" })} }`;
-            }
-        }
-        // schema / Schema
-        if (this.configuration.features.has("Object.schema")) {
-            staticModuleDeclarations["schema"] =
-                code `export const schema = ${ObjectType_schemaExpression.call(this)};`;
-            staticModuleDeclarations["Schema"] =
-                code `export type Schema = typeof schema;`;
-        }
-        // sparqlConstructQuery / sparqlConstructQueryString
-        if (this.configuration.features.has("Object.SPARQL")) {
-            staticModuleDeclarations["sparqlConstructQuery"] =
-                ObjectType_sparqlConstructQueryFunctionDeclaration.call({
-                    name,
-                    configuration: this.configuration,
-                    filterType: this.filterType,
-                    reusables: this.reusables,
-                });
-            staticModuleDeclarations["sparqlConstructQueryString"] =
-                ObjectType_sparqlConstructQueryStringFunctionDeclaration.call({
-                    name,
-                    configuration: this.configuration,
-                    filterType: this.filterType,
-                    reusables: this.reusables,
-                });
-        }
-        // toJson
-        if (this.configuration.features.has("Object.toJson")) {
-            staticModuleDeclarations["toJson"] =
-                code `export const toJson: (${this.thisVariable}: ${this.expression}) => ${this.jsonType().expression} = ${ObjectType_toJsonFunctionExpression.call(this)};`;
-        }
-        // toRdfResource
-        if (this.configuration.features.has("Object.toRdf")) {
-            staticModuleDeclarations["_toRdfResource"] =
-                code `export const _toRdfResource: ${this.reusables.snippets._ToRdfResourceFunction}<${this.identifierTypeAlias}, ${this.expression}> = ${ObjectType_toRdfResourceFunctionExpression.call(this)};`;
-            staticModuleDeclarations["toRdfResource"] =
-                code `export const toRdfResource = ${this.reusables.snippets.wrap_ToRdfResourceFunction}(_toRdfResource);`;
-        }
-        // toString / toStringRecord
-        if (this.configuration.features.has("Object.toString")) {
-            staticModuleDeclarations[`${syntheticNamePrefix}toString`] =
-                code `export const ${syntheticNamePrefix}toString: (${this.thisVariable}: ${this.expression}) => string = ${ObjectType_toStringFunctionExpression.call(this)};`;
-            staticModuleDeclarations["toStringRecord"] =
-                code `export const toStringRecord: (${this.thisVariable}: ${this.expression}) => Record<string, string> = ${ObjectType_toStringRecordFunctionExpression.call(this)};`;
-        }
-        // valueSparqlConstructTriples / valueSparqlWherePatterns
-        if (this.configuration.features.has("Object.SPARQL")) {
-            staticModuleDeclarations["valueSparqlConstructTriples"] =
-                code `export const valueSparqlConstructTriples: ${this.reusables.snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}> = ${ObjectType_valueSparqlConstructTriplesFunctionExpression.call(this)};`;
-            staticModuleDeclarations["valueSparqlWherePatterns"] =
-                code `export const valueSparqlWherePatterns: ${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}> = ${ObjectType_valueSparqlWherePatternsFunctionExpression.call(this)};`;
-        }
-        return staticModuleDeclarations;
+    get createFunction() {
+        return ObjectType_createFunction.call(this);
+    }
+    get createFunctionParameters() {
+        return ObjectType_createFunctionParameters.call(this);
+    }
+    get createUnsafeFunction() {
+        return ObjectType_createUnsafeFunction.call(this);
     }
     get declaration() {
         return !this.extern ? super.declaration : Maybe.empty();
     }
-    get equalsFunction() {
-        return this.name
-            .map((name) => code `${name}.equals`)
-            .orDefaultLazy(() => ObjectType_equalsFunctionExpression.call(this));
+    get jsonObjectType() {
+        return this.jsonTypeFactory.createJsonObjectType(this.properties.flatMap((property) => property.jsonObjectMember.toList()), {
+            name: this.name.map((name) => [name, "Json"]).extract(),
+        });
     }
-    get filterFunction() {
-        return this.name
-            .map((name) => code `${name}.filter`)
-            .orDefaultLazy(() => ObjectType_filterFunctionExpression.call(this));
+    get focusSparqlConstructTriplesFunction() {
+        return ObjectType_focusSparqlConstructTriplesFunction.call(this);
     }
-    get filterType() {
-        return this.name
-            .map((name) => code `${name}.Filter`)
-            .orDefaultLazy(() => ObjectType_filterTypeExpression.call(this));
+    get focusSparqlWherePatternsFunction() {
+        return ObjectType_focusSparqlWherePatternsFunction.call(this);
     }
-    get fromRdfResourceValuesFunction() {
-        return this.name
-            .map((name) => code `${name}.fromRdfResourceValues`)
-            .orDefaultLazy(() => code `((values, options) => values.chainMap(value => value.toResource().chain(resource => ${ObjectType_fromRdfResourceFunctionExpression.call(this)}(resource, options))))`);
+    get fromRdfResourceFunction() {
+        return ObjectType_fromRdfResourceFunction.call(this);
     }
     get fromRdfTypeVariable() {
         return this.rdfTypeProperty.map((rdfTypeProperty) => this.name
@@ -264,15 +144,10 @@ export class ObjectType extends AbstractType {
             .orDefaultLazy(() => this.rdfjsTermExpression(rdfTypeProperty.fromRdfType)));
     }
     get graphqlType() {
-        return new AbstractType.GraphqlType(this.name
+        return new AbstractStructuredType.GraphqlType(this.name
             .map((name) => code `${name}.GraphQL`)
             .orDefaultLazy(() => ObjectType_graphqlTypeExpression.call(this)), this.reusables);
     }
-    get hashFunction() {
-        return this.name
-            .map((name) => code `${name}.hash`)
-            .orDefaultLazy(() => ObjectType_hashFunctionExpression.call(this));
-    }
     get identifierTypeAlias() {
         return code `${this.name.unsafeCoerce()}.Identifier`;
     }
@@ -302,16 +177,28 @@ export class ObjectType extends AbstractType {
                 }
             }));
     }
-    get schemaExpression() {
-        return ObjectType_schemaExpression.call(this);
+    get sparqlConstructQueryFunction() {
+        return ObjectType_sparqlConstructQueryFunction.call({
+            configuration: this.configuration,
+            filterType: this.filterType,
+            _function: this._function.bind(this),
+            focusSparqlConstructTriplesFunction: this.focusSparqlConstructTriplesFunction,
+            focusSparqlWherePatternsFunction: this.focusSparqlWherePatternsFunction,
+            name: this.name,
+            reusables: this.reusables,
+        });
     }
-    get schemaVariable() {
-        return this.name.map((name) => code `${name}.schema`);
+    get sparqlConstructQueryStringFunction() {
+        return ObjectType_sparqlConstructQueryStringFunction.call({
+            configuration: this.configuration,
+            filterType: this.filterType,
+            _function: this._function.bind(this),
+            sparqlConstructQueryFunction: this.sparqlConstructQueryFunction,
+            reusables: this.reusables,
+        });
     }
-    get schemaType() {
-        return this.name
-            .map((name) => code `${name}.Schema`)
-            .orDefaultLazy(() => ObjectType_schemaTypeExpression.call(this));
+    get toRdfResourceFunction() {
+        return ObjectType_toRdfResourceFunction.call(this);
     }
     get toRdfResourceValueTypes() {
         return new Set([...this.identifierType.nodeKinds].map(NodeKind.toTermType));
@@ -319,151 +206,158 @@ export class ObjectType extends AbstractType {
     get toRdfjsResourceType() {
         return code `${this.reusables.imports.Resource}${this.identifierType.kind === "Iri" ? code `<${this.reusables.imports.NamedNode}>` : ""}`;
     }
-    get typeGuardFunction() {
-        return ObjectType_typeGuardFunctionExpression.call(this).map((expression) => this.name.map((name) => code `${name}.is${name}`).orDefault(expression));
-    }
-    get valueSparqlConstructTriplesFunction() {
-        return this.name
-            .map((name) => code `${name}.valueSparqlConstructTriples`)
-            .orDefaultLazy(() => ObjectType_valueSparqlConstructTriplesFunctionExpression.call(this));
+    get toStringRecordFunction() {
+        return ObjectType_toStringRecordFunction.call(this);
     }
-    get valueSparqlWherePatternsFunction() {
-        return this.name
-            .map((name) => code `${name}.valueSparqlWherePatterns`)
-            .orDefaultLazy(() => ObjectType_valueSparqlWherePatternsFunctionExpression.call(this));
-    }
-    get constructorParameters() {
-        let hasQuestionToken = true;
-        const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
-        const propertySignatures = [
-            code `readonly ${syntheticNamePrefix}defaultNamespace?: ${syntheticNamePrefix}DefaultNamespaceT;`,
-        ];
-        for (const property of this.properties) {
-            property.constructorParameter.ifJust((propertyConstructorParameter) => {
-                hasQuestionToken =
-                    hasQuestionToken && propertyConstructorParameter.hasQuestionToken;
-                propertySignatures.push(propertyConstructorParameter.signature);
-            });
-        }
-        const typeExpression = code `{ ${joinCode(propertySignatures)} }`;
-        return {
-            hasQuestionToken,
-            signature: code `parameters${hasQuestionToken ? "?" : ""}: ${typeExpression}`,
-            type: {
-                expression: typeExpression,
-            },
-            variable: code `parameters`,
-        };
+    get typeGuardFunction() {
+        return ObjectType_typeGuardFunction.call(this);
     }
-    get createFunction() {
-        return this.name
-            .map((name) => code `${name}.create`)
-            .orDefaultLazy(() => ObjectType_createFunctionExpression.call(this));
+    get inlineExpression() {
+        return code `{ ${joinCode(this.properties.flatMap((property) => property.declaration.toList()), { on: "\n\n" })} }`;
     }
     get thisVariable() {
         return this.name
             .map((name) => code `_${camelCase(name)}`)
             .orDefault(code `_object`);
     }
-    get toJsonFunction() {
-        return this.name
-            .map((name) => code `${name}.toJson`)
-            .orDefaultLazy(() => ObjectType_toJsonFunctionExpression.call(this));
-    }
-    get toRdfTypesVariable() {
-        return this.rdfTypeProperty.map((rdfTypeProperty) => this.schemaVariable
-            .map((schemaVariable) => code `${schemaVariable}.properties.${rdfTypeProperty.name}.toRdfTypes`)
-            .orDefaultLazy(() => code `${arrayOf(...rdfTypeProperty.toRdfTypes.map((toRdfType) => this.rdfjsTermExpression(toRdfType)))}`));
-    }
-    get toStringFunction() {
-        return this.name
-            .map((name) => code `${name}.${this.configuration.syntheticNamePrefix}toString`)
-            .orDefaultLazy(() => ObjectType_toStringFunctionExpression.call(this));
-    }
-    get inlineExpression() {
-        return code `{ ${joinCode(this.properties.flatMap((property) => property.declaration.toList()), { on: "\n\n" })} }`;
-    }
-    fromJsonExpression({ variables, }) {
-        // Assumes the JSON object has been recursively validated already.
-        return code `${this.name.map((name) => code `${name}.fromJson`).orDefaultLazy(() => ObjectType_fromJsonFunctionExpression.call(this))}(${variables.value})`;
-    }
-    graphqlResolveExpression({ variables, }) {
-        return variables.value;
-    }
-    jsonSchema({ context, }) {
+    propertySubsetExpression(propertyFilter) {
         return this.name
             .map((name) => {
-            let expression = code `${name}.Json.schema()`;
-            if (context === "property" &&
-                this.properties.some((property) => property.recursive)) {
-                expression = code `${this.reusables.imports.z}.lazy((): ${this.reusables.imports.z}.ZodType<${name}.Json> => ${expression})`;
+            const declaredProperties = [];
+            const omitDeclaredProperties = [];
+            const pickDeclaredProperties = [];
+            for (const property of this.properties) {
+                if (property.declaration.isNothing()) {
+                    continue;
+                }
+                declaredProperties.push(property);
+                if (propertyFilter(property)) {
+                    pickDeclaredProperties.push(property);
+                }
+                else {
+                    omitDeclaredProperties.push(property);
+                }
+            }
+            if (pickDeclaredProperties.length === 0) {
+                return code `object`;
+            }
+            if (pickDeclaredProperties.length === declaredProperties.length) {
+                return this.expression;
+            }
+            if (pickDeclaredProperties.length <= declaredProperties.length / 2) {
+                const pickPropertyNames = pickDeclaredProperties.map((property) => code `${literalOf(property.name)}`);
+                if (pickPropertyNames.length === 0) {
+                    return code `object`;
+                }
+                return code `Pick<${name}, ${joinCode(pickPropertyNames, {
+                    on: " | ",
+                })}>`;
+            }
+            else {
+                const omitPropertyNames = omitDeclaredProperties.flatMap((property) => code `${literalOf(property.name)}`);
+                if (omitPropertyNames.length === 0) {
+                    return this.expression;
+                }
+                return code `Omit<${name}, ${joinCode(omitPropertyNames, {
+                    on: " | ",
+                })}>`;
             }
-            return expression;
         })
-            .orDefaultLazy(() => ObjectType_jsonSchemaExpression.call(this));
-    }
-    jsonType() {
-        return new AbstractType.JsonType(this.name
-            .map((name) => code `${name}.Json`)
-            .orDefaultLazy(() => ObjectType_jsonTypeExpression.call(this)));
-    }
-    jsonUiSchemaElement({ variables, }) {
-        return Maybe.of(code `${this.name
-            .map((name) => code `${name}.Json.uiSchema`)
-            .orDefaultLazy(() => ObjectType_jsonUiSchemaFunctionExpression.call(this))}({ scopePrefix: ${variables.scopePrefix} })`);
-    }
-    toJsonExpression({ variables, }) {
-        const toJsonFunction = this.name
-            .map((name) => code `${name}.toJson`)
-            .orDefaultLazy(() => ObjectType_toJsonFunctionExpression.call(this));
-        return code `${toJsonFunction}(${variables.value})`;
-    }
-    toRdfResourceValuesExpression({ variables, }) {
-        const toRdfResourceFunction = this.name
-            .map((name) => code `${name}.toRdfResource`)
-            .orDefaultLazy(() => code `${this.reusables.snippets.wrap_ToRdfResourceFunction}<${this.identifierType.expression}, ${this.expression}>(${ObjectType_toRdfResourceFunctionExpression.call(this)})`);
-        return code `[${toRdfResourceFunction}(${variables.value}, { graph: ${variables.graph}, resourceSet: ${variables.resourceSet} }).identifier]`;
-    }
-    toStringExpression({ variables, }) {
-        return this.name
-            .map((name) => code `${name}.${this.configuration.syntheticNamePrefix}toString(${variables.value})`)
-            .orDefaultLazy(() => code `JSON.stringify(${this.toStringRecordExpression({ variables })})`);
+            .orDefaultLazy(() => {
+            const propertyDeclarations = this.properties.flatMap((property) => propertyFilter(property) ? property.declaration.toList() : []);
+            if (propertyDeclarations.length === 0) {
+                return code `object`;
+            }
+            return code `{ ${joinCode(propertyDeclarations, { on: "\n\n" })} }`;
+        });
     }
-    toStringRecordExpression({ variables, }) {
-        return code `${this.reusables.snippets.compactRecord}({${joinCode(this.properties.flatMap((property) => property
-            .toStringInitializer({
-            variables: {
-                object: variables.value,
-            },
-        })
-            .toList()), { on: "," })}})`;
+    staticModuleDeclarations(name) {
+        let staticModuleDeclarations = {
+            ...super.staticModuleDeclarations(name),
+        };
+        function addFunctionDeclaration(function_) {
+            invariant(function_ instanceof DeclaredCallable);
+            staticModuleDeclarations[function_.unqualifiedName] =
+                code `export ${function_.declaration}`;
+        }
+        if (this.configuration.features.has("Object.create")) {
+            staticModuleDeclarations["CreateParameters"] =
+                code `export type CreateParameters<${this.configuration.syntheticNamePrefix}DefaultNamespaceT extends ${this.reusables.snippets.NamespaceBuilder} = ${this.reusables.snippets.NamespaceBuilder}> = ${this.createFunctionParameters.type.inlineExpression};`;
+            addFunctionDeclaration(this.createFunction);
+            addFunctionDeclaration(this.createUnsafeFunction);
+        }
+        if (this.configuration.features.has("GraphQL") && !this.synthetic) {
+            staticModuleDeclarations["GraphQL"] =
+                code `export const GraphQL = ${ObjectType_graphqlTypeExpression.call(this)};`;
+        }
+        if (this.configuration.features.has("Object.fromRdf")) {
+            addFunctionDeclaration(this._fromRdfResourceFunction);
+            addFunctionDeclaration(this.fromRdfResourceFunction);
+        }
+        if (this.configuration.features.has("Object.SPARQL")) {
+            addFunctionDeclaration(this.focusSparqlConstructTriplesFunction);
+            addFunctionDeclaration(this.focusSparqlWherePatternsFunction);
+            addFunctionDeclaration(this.sparqlConstructQueryFunction);
+            addFunctionDeclaration(this.sparqlConstructQueryStringFunction);
+        }
+        if (this.configuration.features.has("Object.toRdf")) {
+            addFunctionDeclaration(this._toRdfResourceFunction);
+            addFunctionDeclaration(this.toRdfResourceFunction);
+        }
+        if (this.configuration.features.has("Object.toString")) {
+            addFunctionDeclaration(this.toStringRecordFunction);
+        }
+        if (this.configuration.features.has("Object.type")) {
+            staticModuleDeclarations = {
+                ...staticModuleDeclarations,
+                ...ObjectType_identifierTypeDeclarations.call(this),
+            };
+            this.discriminatedType.ifJust(({ discriminantProperty }) => {
+                staticModuleDeclarations["Discriminated"] =
+                    code `export type Discriminated = ${name} & { readonly ${discriminantProperty.name}: ${literalOf(discriminantProperty.values[0])} };`;
+            });
+            this.typeGuardFunction.ifJust(addFunctionDeclaration);
+        }
+        return staticModuleDeclarations;
     }
     lazyProperties;
 }
+__decorate([
+    Memoize()
+], ObjectType.prototype, "_fromRdfResourceFunction", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "_toRdfResourceFunction", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "conversionFunction", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "equalsFunction", null);
+], ObjectType.prototype, "createFunction", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "createFunctionParameters", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "filterFunction", null);
+], ObjectType.prototype, "createUnsafeFunction", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "filterType", null);
+], ObjectType.prototype, "jsonObjectType", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "fromRdfResourceValuesFunction", null);
+], ObjectType.prototype, "focusSparqlConstructTriplesFunction", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "fromRdfTypeVariable", null);
+], ObjectType.prototype, "focusSparqlWherePatternsFunction", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "graphqlType", null);
+], ObjectType.prototype, "fromRdfResourceFunction", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "hashFunction", null);
+], ObjectType.prototype, "fromRdfTypeVariable", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "graphqlType", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "identifierTypeAlias", null);
@@ -481,13 +375,13 @@ __decorate([
 ], ObjectType.prototype, "referencesNamedType", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "schemaExpression", null);
+], ObjectType.prototype, "sparqlConstructQueryFunction", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "schemaVariable", null);
+], ObjectType.prototype, "sparqlConstructQueryStringFunction", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "schemaType", null);
+], ObjectType.prototype, "toRdfResourceFunction", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "toRdfResourceValueTypes", null);
@@ -496,34 +390,13 @@ __decorate([
 ], ObjectType.prototype, "toRdfjsResourceType", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "typeGuardFunction", null);
-__decorate([
-    Memoize()
-], ObjectType.prototype, "valueSparqlConstructTriplesFunction", null);
-__decorate([
-    Memoize()
-], ObjectType.prototype, "valueSparqlWherePatternsFunction", null);
-__decorate([
-    Memoize()
-], ObjectType.prototype, "constructorParameters", null);
+], ObjectType.prototype, "toStringRecordFunction", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "createFunction", null);
+], ObjectType.prototype, "typeGuardFunction", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "thisVariable", null);
-__decorate([
-    Memoize()
-], ObjectType.prototype, "toJsonFunction", null);
-__decorate([
-    Memoize()
-], ObjectType.prototype, "toRdfTypesVariable", null);
-__decorate([
-    Memoize()
-], ObjectType.prototype, "toStringFunction", null);
-__decorate([
-    Memoize()
-], ObjectType.prototype, "jsonType", null);
 (function (ObjectType) {
     ObjectType.IdentifierProperty = ObjectType_IdentifierProperty;
     ObjectType.ShaclProperty = ObjectType_ShaclProperty;