@shaclmate/compiler 3.0.4 → 4.0.1

package/dist/generators/ts/ObjectType.js

@@ -5,39 +5,56 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { camelCase } from "change-case";
-import { Maybe } from "purify-ts";
+import { Maybe, NonEmptyList } from "purify-ts";
 import { invariant } from "ts-invariant";
-import { StructureKind, } from "ts-morph";
 import { Memoize } from "typescript-memoize";
-import * as _ObjectType from "./_ObjectType/index.js";
-import { DeclaredType } from "./DeclaredType.js";
-import { Import } from "./Import.js";
-import { SnippetDeclarations } from "./SnippetDeclarations.js";
-import { Type } from "./Type.js";
-import { objectInitializer } from "./objectInitializer.js";
+import { IdentifierPrefixProperty as _IdentifierPrefixProperty } from "./_ObjectType/IdentifierPrefixProperty.js";
+import { IdentifierProperty as _IdentifierProperty } from "./_ObjectType/IdentifierProperty.js";
+import { identifierTypeDeclarations } from "./_ObjectType/identifierTypeDeclarations.js";
+import { ObjectType_classDeclaration } from "./_ObjectType/ObjectType_classDeclaration.js";
+import { ObjectType_createFunctionDeclaration } from "./_ObjectType/ObjectType_createFunctionDeclaration.js";
+import { ObjectType_equalsFunctionOrMethodDeclaration } from "./_ObjectType/ObjectType_equalsFunctionOrMethodDeclaration.js";
+import { ObjectType_filterFunctionDeclaration } from "./_ObjectType/ObjectType_filterFunctionDeclaration.js";
+import { ObjectType_filterTypeDeclaration } from "./_ObjectType/ObjectType_filterTypeDeclaration.js";
+import { ObjectType_fromRdfTypeVariableStatement } from "./_ObjectType/ObjectType_fromRdfTypeVariableStatement.js";
+import { ObjectType_graphqlTypeVariableStatement } from "./_ObjectType/ObjectType_graphqlTypeVariableStatement.js";
+import { ObjectType_hashFunctionOrMethodDeclarations } from "./_ObjectType/ObjectType_hashFunctionOrMethodDeclarations.js";
+import { ObjectType_interfaceDeclaration } from "./_ObjectType/ObjectType_interfaceDeclaration.js";
+import { ObjectType_isTypeFunctionDeclaration } from "./_ObjectType/ObjectType_isTypeFunctionDeclaration.js";
+import { ObjectType_jsonFunctionDeclarations } from "./_ObjectType/ObjectType_jsonFunctionDeclarations.js";
+import { ObjectType_jsonTypeAliasDeclaration } from "./_ObjectType/ObjectType_jsonTypeAliasDeclaration.js";
+import { ObjectType_objectSetMethodNames } from "./_ObjectType/ObjectType_objectSetMethodNames.js";
+import { ObjectType_rdfFunctionDeclarations } from "./_ObjectType/ObjectType_rdfFunctionDeclarations.js";
+import { ObjectType_schemaVariableStatement } from "./_ObjectType/ObjectType_schemaVariableStatement.js";
+import { ObjectType_sparqlFunctionDeclarations } from "./_ObjectType/ObjectType_sparqlFunctionDeclarations.js";
+import { ShaclProperty as _ShaclProperty } from "./_ObjectType/ShaclProperty.js";
+import { TypeDiscriminantProperty as _TypeDiscriminantProperty } from "./_ObjectType/TypeDiscriminantProperty.js";
+import { AbstractDeclaredType } from "./AbstractDeclaredType.js";
+import { imports } from "./imports.js";
+import { snippets } from "./snippets.js";
 import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
-export class ObjectType extends DeclaredType {
+import { code, def, joinCode } from "./ts-poet-wrapper.js";
+export class ObjectType extends AbstractDeclaredType {
     imports;
-    comment;
-    label;
     toRdfTypes;
     abstract;
     declarationType;
     extern;
     fromRdfType;
+    graphqlArgs = Maybe.empty();
+    identifierType;
     kind = "ObjectType";
     staticModuleName;
     synthetic;
-    typeof = "object";
-    constructor({ abstract, comment, declarationType, extern, fromRdfType, imports, label, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyParentObjectTypes, lazyProperties, staticModuleName, synthetic, toRdfTypes, ...superParameters }) {
+    typeofs = NonEmptyList(["object"]);
+    constructor({ abstract, declarationType, extern, fromRdfType, identifierType, imports, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyParentObjectTypes, lazyProperties, staticModuleName, synthetic, toRdfTypes, ...superParameters }) {
         super(superParameters);
         this.abstract = abstract;
-        this.comment = comment;
         this.declarationType = declarationType;
         this.extern = extern;
         this.fromRdfType = fromRdfType;
+        this.identifierType = identifierType;
         this.imports = imports;
-        this.label = label;
         // Lazily initialize some members in getters to avoid recursive construction
         this.lazyAncestorObjectTypes = lazyAncestorObjectTypes;
         this.lazyChildObjectTypes = lazyChildObjectTypes;
@@ -48,13 +65,13 @@ export class ObjectType extends DeclaredType {
         this.synthetic = synthetic;
         this.toRdfTypes = toRdfTypes;
     }
-    get _discriminatorProperty() {
-        const discriminatorProperty = this.properties.find((property) => property instanceof ObjectType.TypeDiscriminatorProperty);
-        invariant(discriminatorProperty);
+    get _discriminantProperty() {
+        const discriminantProperty = this.properties.find((property) => property instanceof ObjectType.TypeDiscriminantProperty);
+        invariant(discriminantProperty);
         return {
-            name: discriminatorProperty.name,
-            ownValues: discriminatorProperty.type.ownValues,
-            descendantValues: discriminatorProperty.type.descendantValues,
+            name: discriminantProperty.name,
+            ownValues: discriminantProperty.type.ownValues,
+            descendantValues: discriminantProperty.type.descendantValues,
         };
     }
     get ancestorObjectTypes() {
@@ -67,130 +84,102 @@ export class ObjectType extends DeclaredType {
         return [
             {
                 conversionExpression: (value) => value,
-                sourceTypeCheckExpression: (value) => `typeof ${value} === "object" && ${value} instanceof ${this.name}`,
+                sourceTypeCheckExpression: (value) => code `typeof ${value} === "object" && ${value} instanceof ${this.name}`,
                 sourceTypeName: this.name,
+                sourceTypeof: "object",
             },
         ];
     }
-    get declarationImports() {
-        if (this.extern) {
-            return [];
+    get declaration() {
+        const declarations = [];
+        for (const import_ of this.imports) {
+            declarations.push(code `${import_}`);
         }
-        const imports = this.properties.flatMap((property) => property.declarationImports);
-        if (this.features.has("graphql")) {
-            imports.push(Import.GRAPHQL);
-            imports.push(Import.GRAPHQL_SCALARS);
-        }
-        if (this.features.has("json")) {
-            imports.push(Import.ZOD);
-        }
-        if (this.features.has("rdf")) {
-            imports.push(Import.PURIFY);
-            imports.push(Import.RDFJS_RESOURCE);
-        }
-        if (this.features.has("sparql")) {
-            imports.push(Import.SPARQLJS);
+        if (!this.extern) {
+            const staticModuleDeclarations = [];
+            switch (this.declarationType) {
+                case "class": {
+                    declarations.push(ObjectType_classDeclaration.bind(this)());
+                    break;
+                }
+                case "interface": {
+                    declarations.push(ObjectType_interfaceDeclaration.bind(this)());
+                    staticModuleDeclarations.push(...ObjectType_createFunctionDeclaration.bind(this)().toList(), ...ObjectType_equalsFunctionOrMethodDeclaration.bind(this)().toList(), ...ObjectType_hashFunctionOrMethodDeclarations.bind(this)());
+                    break;
+                }
+            }
+            staticModuleDeclarations.push(ObjectType_filterFunctionDeclaration.bind(this)(), ObjectType_filterTypeDeclaration.bind(this)(), ...ObjectType_fromRdfTypeVariableStatement.bind(this)().toList(), ...ObjectType_graphqlTypeVariableStatement.bind(this)().toList(), ...identifierTypeDeclarations.bind(this)(), ...ObjectType_jsonFunctionDeclarations.bind(this)(), ...ObjectType_jsonTypeAliasDeclaration.bind(this)().toList(), ObjectType_isTypeFunctionDeclaration.bind(this)(), ...ObjectType_rdfFunctionDeclarations.bind(this)(), ObjectType_schemaVariableStatement.bind(this)(), ...ObjectType_sparqlFunctionDeclarations.bind(this)());
+            if (staticModuleDeclarations.length > 0) {
+                declarations.push(code `\
+export namespace ${def(this.staticModuleName)} {
+${joinCode(staticModuleDeclarations, { on: "\n\n" })}
+}`);
+            }
         }
-        return imports;
+        return joinCode(declarations, { on: "\n\n" });
     }
-    get declarations() {
-        const declarations = [
-            ..._ObjectType.classDeclaration.bind(this)().toList(),
-            ..._ObjectType.interfaceDeclaration.bind(this)().toList(),
-        ];
-        const staticModuleStatements = [
-            ..._ObjectType.createFunctionDeclaration.bind(this)().toList(),
-            ..._ObjectType.equalsFunctionDeclaration.bind(this)().toList(),
-            ..._ObjectType.fromRdfTypeVariableStatement.bind(this)().toList(),
-            ..._ObjectType.graphqlTypeVariableStatement.bind(this)().toList(),
-            ..._ObjectType.identifierTypeDeclarations.bind(this)(),
-            ..._ObjectType.jsonTypeAliasDeclaration.bind(this)().toList(),
-            ..._ObjectType.jsonFunctionDeclarations.bind(this)(),
-            ..._ObjectType.hashFunctionDeclarations.bind(this)(),
-            ..._ObjectType.rdfFunctionDeclarations.bind(this)(),
-            ..._ObjectType.propertiesVariableStatement.bind(this)().toList(),
-            ..._ObjectType.sparqlFunctionDeclarations.bind(this)(),
-        ];
-        if (staticModuleStatements.length > 0) {
-            declarations.push({
-                isExported: this.export,
-                kind: StructureKind.Module,
-                name: this.staticModuleName,
-                statements: staticModuleStatements,
-            });
-        }
-        return declarations;
+    get descendantFromRdfTypeVariables() {
+        return this.descendantObjectTypes.flatMap((descendantObjectType) => descendantObjectType.fromRdfTypeVariable.toList());
     }
     get descendantFromRdfTypes() {
         return this.descendantObjectTypes.flatMap((descendantObjectType) => descendantObjectType.fromRdfType.toList());
     }
-    get descendantFromRdfTypeVariables() {
-        return this.descendantObjectTypes.flatMap((descendantObjectType) => descendantObjectType.fromRdfTypeVariable.toList());
-    }
     get descendantObjectTypes() {
         return this.lazyDescendantObjectTypes();
     }
-    get discriminatorProperty() {
-        return Maybe.of(this._discriminatorProperty);
+    get discriminantProperty() {
+        return Maybe.of(this._discriminantProperty);
     }
-    get discriminatorValue() {
+    get discriminantValue() {
         return this.name;
     }
     get equalsFunction() {
         switch (this.declarationType) {
             case "class":
-                return `((left, right) => left.${syntheticNamePrefix}equals(right))`;
+                return code `((left, right) => left.${syntheticNamePrefix}equals(right))`;
             case "interface":
-                return `${this.staticModuleName}.${syntheticNamePrefix}equals`;
+                return code `${this.staticModuleName}.${syntheticNamePrefix}equals`;
             default:
                 throw new RangeError(this.declarationType);
         }
     }
+    get filterFunction() {
+        return code `${this.staticModuleName}.${syntheticNamePrefix}filter`;
+    }
+    get filterType() {
+        return code `${this.staticModuleName}.${syntheticNamePrefix}Filter`;
+    }
     get fromRdfTypeVariable() {
-        return this.fromRdfType.map(() => `${this.staticModuleName}.${syntheticNamePrefix}fromRdfType`);
+        return this.fromRdfType.map(() => code `${this.staticModuleName}.${syntheticNamePrefix}fromRdfType`);
     }
-    get graphqlName() {
-        return new Type.GraphqlName(`${this.staticModuleName}.${syntheticNamePrefix}GraphQL`);
+    get graphqlType() {
+        return new AbstractDeclaredType.GraphqlType(code `${this.staticModuleName}.${syntheticNamePrefix}GraphQL`);
     }
     get identifierProperty() {
-        const identifierProperty = this.properties.find((property) => property instanceof ObjectType.IdentifierProperty);
+        const identifierProperty = this.properties.find((property) => property.kind === "IdentifierProperty");
         invariant(identifierProperty);
         return identifierProperty;
     }
-    get identifierType() {
-        return this.identifierProperty.type;
-    }
     get identifierTypeAlias() {
-        return `${this.staticModuleName}.${syntheticNamePrefix}Identifier`;
-    }
-    get jsonName() {
-        return new Type.JsonName(`${this.staticModuleName}.${syntheticNamePrefix}Json`);
+        return code `${this.staticModuleName}.${syntheticNamePrefix}Identifier`;
     }
     get mutable() {
         return this.properties.some((property) => property.mutable);
     }
-    newExpression({ parameters }) {
-        switch (this.declarationType) {
-            case "class":
-                return `new ${this.name}(${parameters})`;
-            case "interface":
-                return `${this.staticModuleName}.${syntheticNamePrefix}create(${parameters})`;
-        }
-    }
     get objectSetMethodNames() {
-        return _ObjectType.objectSetMethodNames.bind(this)();
+        return ObjectType_objectSetMethodNames.bind(this)();
     }
     get ownProperties() {
         if (this.parentObjectTypes.length === 0) {
-            // Consider that a root of the object type hierarchy "owns" the identifier and type discriminator properties
+            // Consider that a root of the object type hierarchy "owns" the identifier and type discriminant properties
             // for all of its subtypes in the hierarchy.
-            invariant(this.properties.length >= 2, this.name);
+            // invariant(this.properties.length >= 2, this.name);
             return this.properties;
         }
         return this.ownShaclProperties;
     }
     get ownShaclProperties() {
-        return this.properties.filter((property) => property instanceof _ObjectType.ShaclProperty);
+        return this.properties.filter((property) => property.kind === "ShaclProperty");
     }
     get parentObjectTypes() {
         return this.lazyParentObjectTypes();
@@ -205,28 +194,40 @@ export class ObjectType extends DeclaredType {
         }
         return properties;
     }
+    get schema() {
+        return code `${this.staticModuleName}.${syntheticNamePrefix}schema`;
+    }
+    get schemaType() {
+        return code `typeof ${this.schema}`;
+    }
+    get sparqlConstructTriplesFunction() {
+        return code `(({ ignoreRdfType, schema, ...otherParameters }: ${snippets.SparqlConstructTriplesFunctionParameters}<${this.filterType}, ${this.schemaType}>) => ${this.staticModuleName}.${syntheticNamePrefix}sparqlConstructTriples({ ignoreRdfType: ignoreRdfType ?? true, ...otherParameters }))`;
+    }
+    get sparqlWherePatternsFunction() {
+        return code `(({ ignoreRdfType, propertyPatterns, schema, valueVariable, ...otherParameters }: ${snippets.SparqlWherePatternsFunctionParameters}<${this.filterType}, ${this.schemaType}>) => (propertyPatterns as readonly ${snippets.SparqlPattern}[]).concat(${this.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns({ focusIdentifier: valueVariable, ignoreRdfType: ignoreRdfType ?? true, ...otherParameters })))`;
+    }
     get toRdfjsResourceType() {
         if (this.parentObjectTypes.length > 0) {
             return this.parentObjectTypes[0].toRdfjsResourceType;
         }
-        return `rdfjsResource.MutableResource${this.identifierType.isNamedNodeKind ? "<rdfjs.NamedNode>" : ""}`;
+        return code `${imports.Resource}${this.identifierType.kind === "IriType" ? code `<${imports.NamedNode}>` : ""}`;
     }
     get thisVariable() {
         switch (this.declarationType) {
             case "class":
-                return "this";
+                return code `this`;
             case "interface":
-                return `_${camelCase(this.name)}`;
+                return code `_${camelCase(this.name)}`;
             default:
                 throw new RangeError(this.declarationType);
         }
     }
     fromJsonExpression({ variables, }) {
         // Assumes the JSON object has been recursively validated already.
-        return `${this.staticModuleName}.${syntheticNamePrefix}fromJson(${variables.value}).unsafeCoerce()`;
+        return code `${this.staticModuleName}.${syntheticNamePrefix}fromJson(${variables.value}).unsafeCoerce()`;
     }
     fromRdfExpression({ variables, }) {
-        return `${variables.resourceValues}.chain(values => values.chainMap(value => value.toResource().chain(resource => ${this.staticModuleName}.${syntheticNamePrefix}fromRdf(resource, { ...${variables.context}, ${variables.ignoreRdfType ? "ignoreRdfType: true, " : ""}objectSet: ${variables.objectSet}, preferredLanguages: ${variables.preferredLanguages} }))))`;
+        return code `${variables.resourceValues}.chain(values => values.chainMap(value => value.toResource().chain(resource => ${this.staticModuleName}.${syntheticNamePrefix}fromRdf(resource, { context: ${variables.context}, ${variables.ignoreRdfType ? "ignoreRdfType: true, " : ""}objectSet: ${variables.objectSet}, preferredLanguages: ${variables.preferredLanguages} }))))`;
     }
     graphqlResolveExpression({ variables, }) {
         return variables.value;
@@ -235,101 +236,52 @@ export class ObjectType extends DeclaredType {
         switch (this.declarationType) {
             case "class":
                 return [
-                    `${variables.value}.${syntheticNamePrefix}hash(${variables.hasher});`,
+                    code `${variables.value}.${syntheticNamePrefix}hash(${variables.hasher});`,
                 ];
             case "interface":
                 return [
-                    `${this.staticModuleName}.${syntheticNamePrefix}hash(${variables.value}, ${variables.hasher});`,
+                    code `${this.staticModuleName}.${syntheticNamePrefix}hash(${variables.value}, ${variables.hasher});`,
                 ];
         }
     }
+    jsonType() {
+        return new AbstractDeclaredType.JsonType(code `${this.staticModuleName}.${syntheticNamePrefix}Json`);
+    }
     jsonUiSchemaElement({ variables, }) {
-        return Maybe.of(`${this.staticModuleName}.${syntheticNamePrefix}jsonUiSchema({ scopePrefix: ${variables.scopePrefix} })`);
+        return Maybe.of(code `${this.staticModuleName}.${syntheticNamePrefix}jsonUiSchema({ scopePrefix: ${variables.scopePrefix} })`);
     }
-    jsonZodSchema({ context, variables, }) {
-        let expression = `${this.staticModuleName}.${syntheticNamePrefix}jsonZodSchema()`;
+    jsonZodSchema({ context, }) {
+        let expression = code `${this.staticModuleName}.${syntheticNamePrefix}jsonZodSchema()`;
         if (context === "property" &&
             this.properties.some((property) => property.recursive)) {
-            expression = `${variables.zod}.lazy((): ${variables.zod}.ZodType<${this.staticModuleName}.${syntheticNamePrefix}Json> => ${expression})`;
+            expression = code `${imports.z}.lazy((): ${imports.z}.ZodType<${this.staticModuleName}.${syntheticNamePrefix}Json> => ${expression})`;
         }
         return expression;
     }
-    snippetDeclarations({ recursionStack, }) {
-        if (recursionStack.some((type) => Object.is(type, this))) {
-            return [];
-        }
-        const snippetDeclarations = [];
-        if (this.features.has("equals")) {
-            snippetDeclarations.push(SnippetDeclarations.EqualsResult);
-        }
-        if (this.features.has("rdf")) {
-            snippetDeclarations.push(SnippetDeclarations.RdfVocabularies);
-        }
-        if (this.features.has("sparql") && this.fromRdfType.isJust()) {
-            snippetDeclarations.push(SnippetDeclarations.sparqlInstancesOfPattern);
-        }
-        if ((this.features.has("json") || this.features.has("rdf")) &&
-            this.parentObjectTypes.length > 0) {
-            snippetDeclarations.push(SnippetDeclarations.UnwrapR);
-        }
-        recursionStack.push(this);
-        for (const property of this.ownProperties) {
-            snippetDeclarations.push(...property.snippetDeclarations({
-                features: this.features,
-                recursionStack,
-            }));
-        }
-        invariant(Object.is(recursionStack.pop(), this));
-        return snippetDeclarations;
-    }
-    sparqlConstructTemplateTriples(parameters) {
-        switch (parameters.context) {
-            case "object":
-                return super.sparqlConstructTemplateTriples(parameters);
-            case "subject":
-                return [
-                    `...${this.staticModuleName}.${syntheticNamePrefix}sparqlConstructTemplateTriples(${objectInitializer({
-                        ignoreRdfType: parameters.allowIgnoreRdfType ? true : undefined, // Can ignore the rdf:type when the object is nested
-                        subject: parameters.variables.subject,
-                        variablePrefix: parameters.variables.variablePrefix,
-                    })})`,
-                ];
-        }
-    }
-    sparqlWherePatterns(parameters) {
-        switch (parameters.context) {
-            case "object":
-                return super.sparqlWherePatterns(parameters);
-            case "subject":
-                return [
-                    `...${this.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns(${objectInitializer({
-                        ignoreRdfType: parameters.allowIgnoreRdfType ? true : undefined, // Can ignore the rdf:type when the object is nested
-                        preferredLanguages: parameters.variables.preferredLanguages,
-                        subject: parameters.variables.subject,
-                        variablePrefix: parameters.variables.variablePrefix,
-                    })})`,
-                ];
+    newExpression({ parameters }) {
+        switch (this.declarationType) {
+            case "class":
+                return code `new ${this.name}(${parameters})`;
+            case "interface":
+                return code `${this.staticModuleName}.${syntheticNamePrefix}create(${parameters})`;
         }
     }
     toJsonExpression({ variables, }) {
         switch (this.declarationType) {
             case "class":
-                return `${variables.value}.${syntheticNamePrefix}toJson()`;
+                return code `${variables.value}.${syntheticNamePrefix}toJson()`;
             case "interface":
-                return `${this.staticModuleName}.${syntheticNamePrefix}toJson(${variables.value})`;
+                return code `${this.staticModuleName}.${syntheticNamePrefix}toJson(${variables.value})`;
         }
     }
     toRdfExpression({ variables, }) {
         switch (this.declarationType) {
             case "class":
-                return `[${variables.value}.${syntheticNamePrefix}toRdf({ mutateGraph: ${variables.mutateGraph}, resourceSet: ${variables.resourceSet} }).identifier]`;
+                return code `[${variables.value}.${syntheticNamePrefix}toRdf({ graph: ${variables.graph}, resourceSet: ${variables.resourceSet} }).identifier]`;
             case "interface":
-                return `[${this.staticModuleName}.${syntheticNamePrefix}toRdf(${variables.value}, { mutateGraph: ${variables.mutateGraph}, resourceSet: ${variables.resourceSet} }).identifier]`;
+                return code `[${this.staticModuleName}.${syntheticNamePrefix}toRdf(${variables.value}, { graph: ${variables.graph}, resourceSet: ${variables.resourceSet} }).identifier]`;
         }
     }
-    useImports() {
-        return this.imports;
-    }
     ensureAtMostOneSuperObjectType() {
         if (this.parentObjectTypes.length > 1) {
             throw new RangeError(`object type '${this.name}' has multiple super object types`);
@@ -343,7 +295,7 @@ export class ObjectType extends DeclaredType {
 }
 __decorate([
     Memoize()
-], ObjectType.prototype, "_discriminatorProperty", null);
+], ObjectType.prototype, "_discriminantProperty", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "ancestorObjectTypes", null);
@@ -355,40 +307,40 @@ __decorate([
 ], ObjectType.prototype, "conversions", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "descendantFromRdfTypes", null);
+], ObjectType.prototype, "descendantFromRdfTypeVariables", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "descendantFromRdfTypeVariables", null);
+], ObjectType.prototype, "descendantFromRdfTypes", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "descendantObjectTypes", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "discriminatorProperty", null);
+], ObjectType.prototype, "discriminantProperty", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "discriminatorValue", null);
+], ObjectType.prototype, "discriminantValue", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "equalsFunction", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "fromRdfTypeVariable", null);
+], ObjectType.prototype, "filterFunction", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "graphqlName", null);
+], ObjectType.prototype, "filterType", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "identifierProperty", null);
+], ObjectType.prototype, "fromRdfTypeVariable", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "identifierType", null);
+], ObjectType.prototype, "graphqlType", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "identifierTypeAlias", null);
+], ObjectType.prototype, "identifierProperty", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "jsonName", null);
+], ObjectType.prototype, "identifierTypeAlias", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "mutable", null);
@@ -407,6 +359,18 @@ __decorate([
 __decorate([
     Memoize()
 ], ObjectType.prototype, "properties", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "schema", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "schemaType", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "sparqlConstructTriplesFunction", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "sparqlWherePatternsFunction", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "toRdfjsResourceType", null);
@@ -415,14 +379,11 @@ __decorate([
 ], ObjectType.prototype, "thisVariable", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "useImports", null);
+], ObjectType.prototype, "jsonType", null);
 (function (ObjectType) {
-    ObjectType.EagerShaclProperty = _ObjectType.EagerShaclProperty;
-    ObjectType.IdentifierPrefixProperty = _ObjectType.IdentifierPrefixProperty;
-    ObjectType.IdentifierProperty = _ObjectType.IdentifierProperty;
-    ObjectType.LazyShaclProperty = _ObjectType.LazyShaclProperty;
-    ObjectType.Property = _ObjectType.Property;
-    ObjectType.ShaclProperty = _ObjectType.ShaclProperty;
-    ObjectType.TypeDiscriminatorProperty = _ObjectType.TypeDiscriminatorProperty;
+    ObjectType.IdentifierPrefixProperty = _IdentifierPrefixProperty;
+    ObjectType.IdentifierProperty = _IdentifierProperty;
+    ObjectType.ShaclProperty = _ShaclProperty;
+    ObjectType.TypeDiscriminantProperty = _TypeDiscriminantProperty;
 })(ObjectType || (ObjectType = {}));
 //# sourceMappingURL=ObjectType.js.map