@shaclmate/compiler 4.0.38 → 4.0.40

package/dist/generators/ts/IriType.js

@@ -7,48 +7,55 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
-import { arrayOf, code, joinCode, literalOf, } from "./ts-poet-wrapper.js";
+import { arrayOf, code, joinCode } from "./ts-poet-wrapper.js";
 export class IriType extends AbstractIdentifierType {
     filterFunction = code `${this.reusables.snippets.filterIri}`;
     filterType = code `${this.reusables.snippets.IriFilter}`;
-    kind = "IriType";
+    kind = "Iri";
     nodeKinds = nodeKinds;
-    schemaType = code `${this.reusables.snippets.IriSchema}`;
+    schemaType = code `${this.reusables.snippets.IriSchema}<${this.valueTypeExpression}>`;
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.iriSparqlWherePatterns}`;
     get conversionFunction() {
-        const IriT = this.in_.length > 0
-            ? code `${joinCode(this.in_.map((iri) => code `${literalOf(iri.value)}`), { on: "| " })}`
-            : code `string`;
         return Maybe.of({
-            code: code `${this.reusables.snippets.convertToIri}<${IriT}>`,
+            code: code `${this.reusables.snippets.convertToIri}<${this.valueTypeExpression}>`,
             sourceTypes: [
                 {
-                    name: IriT,
+                    expression: this.valueTypeExpression,
                     typeof: "string",
                 },
                 {
-                    name: this.name,
+                    expression: this.expression,
                     typeof: "object",
                 },
             ],
         });
     }
-    get name() {
+    get expression() {
         if (this.in_.length > 0) {
-            // Treat sh:in as a union of the IRIs
-            // rdfjs.NamedNode<"http://example.com/1" | "http://example.com/2">
-            return code `${this.reusables.imports.NamedNode}<${joinCode(this.in_.map((iri) => code `${literalOf(iri.value)}`), { on: "| " })}>`;
+            return code `${this.reusables.imports.NamedNode}<${this.valueTypeExpression}>`;
         }
         return code `${this.reusables.imports.NamedNode}`;
     }
     get parseFunction() {
         if (this.in_.length > 0) {
-            return code `(identifier: string) => ${this.reusables.snippets.parseIri}(identifier).chain((identifier) => { switch (identifier.value) { ${joinCode(this.in_.map((iri) => code `case "${iri.value}": return ${this.reusables.imports.Right}(identifier as ${this.name});`))} default: return ${this.reusables.imports.Left}(new Error("expected NamedNode identifier to be one of ${this.in_.map((iri) => iri.value).join(" ")}")); } })`;
+            return code `(identifier: string) => ${this.reusables.snippets.parseIri}(identifier).chain((identifier) => { switch (identifier.value) { ${joinCode(this.in_.map((iri) => code `case "${iri.value}": return ${this.reusables.imports.Right}(identifier as ${this.expression});`))} default: return ${this.reusables.imports.Left}(new Error("expected NamedNode identifier to be one of ${this.in_.map((iri) => iri.value).join(" ")}")); } })`;
         }
         return code `${this.reusables.snippets.parseIri}`;
     }
+    get schemaInitializers() {
+        let initializers = super.schemaInitializers;
+        if (this.in_.length > 0) {
+            initializers = initializers.concat(code `in: ${arrayOf(...this.in_.map((in_) => this.rdfjsTermExpression(in_)))}`);
+        }
+        return initializers;
+    }
+    get valueTypeExpression() {
+        return this.in_.length > 0
+            ? code `(${this.in_.map((in_) => `"${in_.value}"`).join(" | ")})`
+            : code `string`;
+    }
     fromJsonExpression({ variables, }) {
-        return code `${this.reusables.imports.Either}.of<Error, ${this.name}>(${this.reusables.imports.dataFactory}.namedNode(${variables.value}["@id"]))`;
+        return code `${this.reusables.imports.Either}.of<Error, ${this.expression}>(${this.reusables.imports.dataFactory}.namedNode(${variables.value}["@id"]))`;
     }
     jsonSchema({ includeDiscriminantProperty, }) {
         let idSchema;
@@ -69,12 +76,7 @@ export class IriType extends AbstractIdentifierType {
         const discriminantProperty = parameters?.includeDiscriminantProperty
             ? `, readonly termType: "NamedNode"`
             : "";
-        if (this.in_.length > 0) {
-            // Treat sh:in as a union of the IRIs
-            // rdfjs.NamedNode<"http://example.com/1" | "http://example.com/2">
-            return new AbstractIdentifierType.JsonType(code `{ readonly "@id": ${this.in_.map((iri) => `"${iri.value}"`).join(" | ")}${discriminantProperty} }`);
-        }
-        return new AbstractIdentifierType.JsonType(code `{ readonly "@id": string${discriminantProperty} }`);
+        return new AbstractIdentifierType.JsonType(code `{ readonly "@id": ${this.valueTypeExpression}${discriminantProperty} }`);
     }
     toJsonExpression({ includeDiscriminantProperty, variables, }) {
         const discriminantProperty = includeDiscriminantProperty
@@ -96,10 +98,13 @@ __decorate([
 ], IriType.prototype, "conversionFunction", null);
 __decorate([
     Memoize()
-], IriType.prototype, "name", null);
+], IriType.prototype, "expression", null);
 __decorate([
     Memoize()
 ], IriType.prototype, "parseFunction", null);
+__decorate([
+    Memoize()
+], IriType.prototype, "valueTypeExpression", null);
 __decorate([
     Memoize()
 ], IriType.prototype, "jsonType", null);

package/dist/generators/ts/LazyObjectOptionType.d.ts

@@ -7,6 +7,7 @@ declare const Super: (abstract new ({ partialType, resolveType, ...superParamete
     partialType: OptionType<AbstractLazyObjectType.ObjectTypeConstraint>;
     resolveType: OptionType<AbstractLazyObjectType.ObjectTypeConstraint>;
 } & {
+    alias: Maybe<string>;
     comment: Maybe<string>;
     configuration: import("./TsGenerator.js").TsGenerator.Configuration;
     label: Maybe<string>;
@@ -18,7 +19,7 @@ declare const Super: (abstract new ({ partialType, resolveType, ...superParamete
 };
 export declare class LazyObjectOptionType extends Super {
     readonly graphqlArgs: Super["graphqlArgs"];
-    readonly kind = "LazyObjectOptionType";
+    readonly kind = "LazyObjectOption";
     get conversionFunction(): Maybe<AbstractLazyObjectType.ConversionFunction>;
     protected get runtimeClass(): {
         name: Code;

package/dist/generators/ts/LazyObjectOptionType.js

@@ -11,25 +11,25 @@ import { code } from "./ts-poet-wrapper.js";
 const Super = (AbstractLazyObjectType);
 export class LazyObjectOptionType extends Super {
     graphqlArgs = Maybe.empty();
-    kind = "LazyObjectOptionType";
+    kind = "LazyObjectOption";
     get conversionFunction() {
         return Maybe.of({
-            code: code `${this.reusables.snippets.convertToLazyObjectOption}<${this.resolveType.itemType.identifierTypeAlias}, ${this.partialType.itemType.name}, ${this.resolveType.itemType.name}>(${this.resolveToPartialFunction({ partialType: this.partialType.itemType, resolveType: this.resolveType.itemType })})`,
+            code: code `${this.reusables.snippets.convertToLazyObjectOption}<${this.resolveType.itemType.identifierTypeAlias}, ${this.partialType.itemType.expression}, ${this.resolveType.itemType.expression}>(${this.resolveToPartialFunction({ partialType: this.partialType.itemType, resolveType: this.resolveType.itemType })})`,
             sourceTypes: [
                 {
-                    name: this.name,
+                    expression: this.expression,
                     typeof: "object",
                 },
                 {
-                    name: this.resolveType.name,
+                    expression: this.resolveType.expression,
                     typeof: "object",
                 },
                 {
-                    name: this.resolveType.itemType.name,
+                    expression: this.resolveType.itemType.expression,
                     typeof: "object",
                 },
                 {
-                    name: "undefined",
+                    expression: code `undefined`,
                     typeof: "undefined",
                 },
             ],
@@ -37,7 +37,7 @@ export class LazyObjectOptionType extends Super {
     }
     get runtimeClass() {
         return {
-            name: code `${this.reusables.snippets.LazyObjectOption}<${this.resolveType.itemType.identifierTypeAlias}, ${this.partialType.itemType.name}, ${this.resolveType.itemType.name}>`,
+            name: code `${this.reusables.snippets.LazyObjectOption}<${this.resolveType.itemType.identifierTypeAlias}, ${this.partialType.itemType.expression}, ${this.resolveType.itemType.expression}>`,
             partialPropertyName: "partial",
             rawName: code `${this.reusables.snippets.LazyObjectOption}`,
         };

package/dist/generators/ts/LazyObjectSetType.d.ts

@@ -4,7 +4,7 @@ import type { SetType } from "./SetType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class LazyObjectSetType extends AbstractLazyObjectType<SetType<AbstractLazyObjectType.ObjectTypeConstraint>, SetType<AbstractLazyObjectType.ObjectTypeConstraint>> {
     readonly graphqlArgs: Super["graphqlArgs"];
-    readonly kind = "LazyObjectSetType";
+    readonly kind = "LazyObjectSet";
     get conversionFunction(): Maybe<AbstractLazyObjectType.ConversionFunction>;
     protected get runtimeClass(): {
         name: Code;

package/dist/generators/ts/LazyObjectSetType.js

@@ -17,21 +17,21 @@ export class LazyObjectSetType extends AbstractLazyObjectType {
             type: code `${this.reusables.imports.GraphQLInt}`,
         },
     });
-    kind = "LazyObjectSetType";
+    kind = "LazyObjectSet";
     get conversionFunction() {
         return Maybe.of({
-            code: code `${this.reusables.snippets.convertToLazyObjectSet}<${this.resolveType.itemType.identifierTypeAlias}, ${this.partialType.itemType.name}, ${this.resolveType.itemType.name}>(${this.resolveToPartialFunction({ partialType: this.partialType.itemType, resolveType: this.resolveType.itemType })})`,
+            code: code `${this.reusables.snippets.convertToLazyObjectSet}<${this.resolveType.itemType.identifierTypeAlias}, ${this.partialType.itemType.expression}, ${this.resolveType.itemType.expression}>(${this.resolveToPartialFunction({ partialType: this.partialType.itemType, resolveType: this.resolveType.itemType })})`,
             sourceTypes: [
                 {
-                    name: this.name,
+                    expression: this.expression,
                     typeof: "object",
                 },
                 {
-                    name: this.resolveType.name,
+                    expression: this.resolveType.expression,
                     typeof: "object",
                 },
                 {
-                    name: "undefined",
+                    expression: code `undefined`,
                     typeof: "undefined",
                 },
             ],
@@ -39,7 +39,7 @@ export class LazyObjectSetType extends AbstractLazyObjectType {
     }
     get runtimeClass() {
         return {
-            name: code `${this.reusables.snippets.LazyObjectSet}<${this.resolveType.itemType.identifierTypeAlias}, ${this.partialType.itemType.name}, ${this.resolveType.itemType.name}>`,
+            name: code `${this.reusables.snippets.LazyObjectSet}<${this.resolveType.itemType.identifierTypeAlias}, ${this.partialType.itemType.expression}, ${this.resolveType.itemType.expression}>`,
             partialPropertyName: "partials",
             rawName: code `${this.reusables.snippets.LazyObjectSet}`,
         };

package/dist/generators/ts/LazyObjectType.d.ts

@@ -3,7 +3,7 @@ import { AbstractLazyObjectType } from "./AbstractLazyObjectType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class LazyObjectType extends AbstractLazyObjectType<AbstractLazyObjectType.ObjectTypeConstraint, AbstractLazyObjectType.ObjectTypeConstraint> {
     readonly graphqlArgs: Super["graphqlArgs"];
-    readonly kind = "LazyObjectType";
+    readonly kind = "LazyObject";
     get conversionFunction(): Maybe<AbstractLazyObjectType.ConversionFunction>;
     protected get runtimeClass(): {
         name: Code;

package/dist/generators/ts/LazyObjectType.js

@@ -10,17 +10,17 @@ import { AbstractLazyObjectType } from "./AbstractLazyObjectType.js";
 import { code } from "./ts-poet-wrapper.js";
 export class LazyObjectType extends AbstractLazyObjectType {
     graphqlArgs = Maybe.empty();
-    kind = "LazyObjectType";
+    kind = "LazyObject";
     get conversionFunction() {
         return Maybe.of({
-            code: code `${this.reusables.snippets.convertToLazyObject}<${this.resolveType.identifierTypeAlias}, ${this.partialType.name}, ${this.resolveType.name}>(${this.resolveToPartialFunction({ partialType: this.partialType, resolveType: this.resolveType })})`,
+            code: code `${this.reusables.snippets.convertToLazyObject}<${this.resolveType.identifierTypeAlias}, ${this.partialType.expression}, ${this.resolveType.expression}>(${this.resolveToPartialFunction({ partialType: this.partialType, resolveType: this.resolveType })})`,
             sourceTypes: [
                 {
-                    name: this.name,
+                    expression: this.expression,
                     typeof: "object",
                 },
                 {
-                    name: this.resolveType.name,
+                    expression: this.resolveType.expression,
                     typeof: "object",
                 },
             ],
@@ -28,7 +28,7 @@ export class LazyObjectType extends AbstractLazyObjectType {
     }
     get runtimeClass() {
         return {
-            name: code `${this.reusables.snippets.LazyObject}<${this.resolveType.identifierTypeAlias}, ${this.partialType.name}, ${this.resolveType.name}>`,
+            name: code `${this.reusables.snippets.LazyObject}<${this.resolveType.identifierTypeAlias}, ${this.partialType.expression}, ${this.resolveType.expression}>`,
             partialPropertyName: "partial",
             rawName: code `${this.reusables.snippets.LazyObject}`,
         };

package/dist/generators/ts/ListType.d.ts

@@ -1,6 +1,5 @@
 import type { NamedNode } from "@rdfjs/types";
 import { AbstractCollectionType } from "./AbstractCollectionType.js";
-import type { AnonymousUnionType } from "./AnonymousUnionType.js";
 import type { BigDecimalType } from "./BigDecimalType.js";
 import type { BigIntType } from "./BigIntType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
@@ -12,17 +11,17 @@ import type { IdentifierType } from "./IdentifierType.js";
 import type { IntType } from "./IntType.js";
 import type { IriType } from "./IriType.js";
 import type { LiteralType } from "./LiteralType.js";
-import type { NamedObjectType } from "./NamedObjectType.js";
-import type { NamedObjectUnionType } from "./NamedObjectUnionType.js";
-import type { NamedUnionType } from "./NamedUnionType.js";
+import type { ObjectType } from "./ObjectType.js";
+import type { ObjectUnionType } from "./ObjectUnionType.js";
 import type { StringType } from "./StringType.js";
 import type { TermType } from "./TermType.js";
 import type { Type } from "./Type.js";
 import { type Code } from "./ts-poet-wrapper.js";
+import type { UnionType } from "./UnionType.js";
 export declare class ListType<ItemTypeT extends ListType.ItemType> extends AbstractCollectionType<ItemTypeT> {
     private readonly identifierNodeKind;
     private readonly toRdfTypes;
-    readonly kind = "ListType";
+    readonly kind = "List";
     constructor({ identifierNodeKind, toRdfTypes, ...superParameters }: {
         identifierNodeKind: ListType<ItemTypeT>["identifierNodeKind"];
         toRdfTypes: readonly NamedNode[];
@@ -35,7 +34,7 @@ export declare class ListType<ItemTypeT extends ListType.ItemType> extends Abstr
     toStringExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["toStringExpression"]>[0]): Code;
 }
 export declare namespace ListType {
-    type ItemType = AnonymousUnionType | BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | FloatType | IdentifierType | IntType | IriType | LiteralType | NamedObjectUnionType | NamedUnionType | NamedObjectType | StringType | TermType;
+    type ItemType = BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | FloatType | IdentifierType | IntType | IriType | LiteralType | ObjectUnionType | ObjectType | StringType | TermType | UnionType<Type>;
     function isItemType(type: Type): type is ItemType;
 }
 //# sourceMappingURL=ListType.d.ts.map

package/dist/generators/ts/ListType.js

@@ -11,7 +11,7 @@ import { code, joinCode } from "./ts-poet-wrapper.js";
 export class ListType extends AbstractCollectionType {
     identifierNodeKind;
     toRdfTypes;
-    kind = "ListType";
+    kind = "List";
     constructor({ identifierNodeKind, toRdfTypes, ...superParameters }) {
         super(superParameters);
         this.identifierNodeKind = identifierNodeKind;
@@ -102,31 +102,30 @@ __decorate([
 (function (ListType) {
     function isItemType(type) {
         switch (type.kind) {
-            case "AnonymousUnionType":
-            case "BigDecimalType":
-            case "BigIntType":
-            case "BlankNodeType":
-            case "BooleanType":
-            case "DateTimeType":
-            case "DateType":
-            case "FloatType":
-            case "IdentifierType":
-            case "IriType":
-            case "IntType":
-            case "LiteralType":
-            case "NamedObjectUnionType":
-            case "NamedUnionType":
-            case "NamedObjectType":
-            case "StringType":
-            case "TermType":
+            case "BigDecimal":
+            case "BigInt":
+            case "BlankNode":
+            case "Boolean":
+            case "DateTime":
+            case "Date":
+            case "Float":
+            case "Identifier":
+            case "Iri":
+            case "Int":
+            case "Literal":
+            case "ObjectUnion":
+            case "Object":
+            case "String":
+            case "Term":
+            case "Union":
                 return true;
-            case "DefaultValueType":
-            case "LazyObjectOptionType":
-            case "LazyObjectSetType":
-            case "LazyObjectType":
-            case "ListType":
-            case "OptionType":
-            case "SetType":
+            case "DefaultValue":
+            case "LazyObjectOption":
+            case "LazyObjectSet":
+            case "LazyObject":
+            case "List":
+            case "Option":
+            case "Set":
                 return false;
         }
     }

package/dist/generators/ts/LiteralType.d.ts

@@ -3,14 +3,15 @@ import { Maybe } from "purify-ts";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class LiteralType extends AbstractLiteralType {
-    readonly name: Code;
+    readonly expression: Code;
     readonly conversionFunction: Maybe<AbstractLiteralType.ConversionFunction>;
     readonly filterFunction: Code;
     readonly filterType: Code;
-    readonly kind = "LiteralType";
+    readonly kind = "Literal";
     readonly schemaType: Code;
     readonly valueSparqlWherePatternsFunction: Code;
     get graphqlType(): AbstractLiteralType.GraphqlType;
+    protected get schemaInitializers(): readonly Code[];
     fromJsonExpression({ variables, }: Parameters<AbstractLiteralType["fromJsonExpression"]>[0]): Code;
     graphqlResolveExpression(_parameters: Parameters<AbstractLiteralType["graphqlResolveExpression"]>[0]): Code;
     jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractLiteralType["jsonSchema"]>[0]): Code;

package/dist/generators/ts/LiteralType.js

@@ -1,36 +1,43 @@
 import { xsd } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
-import { code } from "./ts-poet-wrapper.js";
+import { arrayOf, code } from "./ts-poet-wrapper.js";
 export class LiteralType extends AbstractLiteralType {
-    name = code `${this.reusables.imports.Literal}`;
+    expression = code `${this.reusables.imports.Literal}`;
     conversionFunction = Maybe.of({
         code: code `${this.reusables.snippets.convertToLiteral}`,
         sourceTypes: [
             ...["bigint", "boolean", "number", "string"].map((typeof_) => ({
-                name: typeof_,
+                expression: code `${typeof_}`,
                 typeof: typeof_,
             })),
             {
-                name: "Date",
+                expression: code `Date`,
                 typeof: "object",
             },
             {
-                name: code `${this.reusables.imports.Literal}`,
+                expression: code `${this.reusables.imports.Literal}`,
                 typeof: "object",
             },
         ],
     });
     filterFunction = code `${this.reusables.snippets.filterLiteral}`;
     filterType = code `${this.reusables.snippets.LiteralFilter}`;
-    kind = "LiteralType";
+    kind = "Literal";
     schemaType = code `${this.reusables.snippets.LiteralSchema}`;
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.literalSparqlWherePatterns}`;
     get graphqlType() {
         throw new Error("not implemented");
     }
+    get schemaInitializers() {
+        let initializers = super.schemaInitializers;
+        if (this.in_.length > 0) {
+            initializers = initializers.concat(code `in: ${arrayOf(...this.in_.map((in_) => this.rdfjsTermExpression(in_)))}`);
+        }
+        return initializers;
+    }
     fromJsonExpression({ variables, }) {
-        return code `${this.reusables.imports.Either}.of<Error, ${this.name}>(${this.reusables.imports.dataFactory}.literal(${variables.value}["@value"], ${variables.value}["@language"] !== undefined ? ${variables.value}["@language"] : (${variables.value}["@type"] !== undefined ? ${this.reusables.imports.dataFactory}.namedNode(${variables.value}["@type"]!) : undefined)))`;
+        return code `${this.reusables.imports.Either}.of<Error, ${this.expression}>(${this.reusables.imports.dataFactory}.literal(${variables.value}["@value"], ${variables.value}["@language"] !== undefined ? ${variables.value}["@language"] : (${variables.value}["@type"] !== undefined ? ${this.reusables.imports.dataFactory}.namedNode(${variables.value}["@type"]!) : undefined)))`;
     }
     graphqlResolveExpression(_parameters) {
         throw new Error("not implemented");

package/dist/generators/ts/{NamedObjectType.d.ts → ObjectType.d.ts}

@@ -1,55 +1,55 @@
 import type { NamedNode } from "@rdfjs/types";
 import { Maybe } from "purify-ts";
-import { DiscriminantProperty as _DiscriminantProperty } from "./_NamedObjectType/DiscriminantProperty.js";
-import { IdentifierProperty as _IdentifierProperty } from "./_NamedObjectType/IdentifierProperty.js";
-import type { Property as _Property } from "./_NamedObjectType/Property.js";
-import { ShaclProperty as _ShaclProperty } from "./_NamedObjectType/ShaclProperty.js";
+import { DiscriminantProperty as _DiscriminantProperty } from "./_ObjectType/DiscriminantProperty.js";
+import { IdentifierProperty as _IdentifierProperty } from "./_ObjectType/IdentifierProperty.js";
+import type { Property as _Property } from "./_ObjectType/Property.js";
+import { ShaclProperty as _ShaclProperty } from "./_ObjectType/ShaclProperty.js";
 import { AbstractType } from "./AbstractType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
 import type { IdentifierType } from "./IdentifierType.js";
 import type { IriType } from "./IriType.js";
 import type { Type } from "./Type.js";
 import { type Code } from "./ts-poet-wrapper.js";
-export declare class NamedObjectType extends AbstractType {
+export declare class ObjectType extends AbstractType {
     protected readonly toRdfTypes: readonly NamedNode[];
     readonly conversionFunction: Maybe<AbstractType.ConversionFunction>;
     readonly extern: boolean;
     readonly fromRdfType: Maybe<NamedNode>;
     readonly graphqlArgs: AbstractType["graphqlArgs"];
     readonly identifierType: BlankNodeType | IdentifierType | IriType;
-    readonly kind = "NamedObjectType";
-    readonly name: string;
+    readonly kind = "Object";
     readonly recursive: boolean;
+    readonly referencesObjectType = true;
     readonly synthetic: boolean;
     readonly typeofs: "object"[];
     readonly validationFunction: Maybe<Code>;
-    constructor({ extern, fromRdfType, identifierType, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyDiscriminantProperty, lazyParentObjectTypes, lazyProperties, name, recursive, synthetic, toRdfTypes, ...superParameters }: {
+    constructor({ extern, fromRdfType, identifierType, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyDiscriminantProperty, lazyParentObjectTypes, lazyProperties, recursive, synthetic, toRdfTypes, ...superParameters }: {
         comment: Maybe<string>;
         extern: boolean;
         fromRdfType: Maybe<NamedNode>;
         identifierType: BlankNodeType | IdentifierType | IriType;
         label: Maybe<string>;
-        lazyAncestorObjectTypes: () => readonly NamedObjectType[];
-        lazyChildObjectTypes: () => readonly NamedObjectType[];
-        lazyDiscriminantProperty: (namedObjectType: NamedObjectType) => NamedObjectType.DiscriminantProperty;
-        lazyDescendantObjectTypes: () => readonly NamedObjectType[];
-        lazyParentObjectTypes: () => readonly NamedObjectType[];
-        lazyProperties: (namedObjectType: NamedObjectType) => readonly NamedObjectType.Property[];
-        name: string;
+        lazyAncestorObjectTypes: () => readonly ObjectType[];
+        lazyChildObjectTypes: () => readonly ObjectType[];
+        lazyDiscriminantProperty: (namedObjectType: ObjectType) => ObjectType.DiscriminantProperty;
+        lazyDescendantObjectTypes: () => readonly ObjectType[];
+        lazyParentObjectTypes: () => readonly ObjectType[];
+        lazyProperties: (namedObjectType: ObjectType) => readonly ObjectType.Property[];
         recursive: boolean;
         synthetic: boolean;
         toRdfTypes: readonly NamedNode[];
     } & ConstructorParameters<typeof AbstractType>[0]);
-    get _discriminantProperty(): NamedObjectType.DiscriminantProperty;
-    get ancestorObjectTypes(): readonly NamedObjectType[];
-    get childObjectTypes(): readonly NamedObjectType[];
+    get _discriminantProperty(): ObjectType.DiscriminantProperty;
+    get ancestorObjectTypes(): readonly ObjectType[];
+    get childObjectTypes(): readonly ObjectType[];
     get declaration(): Maybe<Code>;
     get descendantFromRdfTypeVariables(): readonly Code[];
     get descendantFromRdfTypes(): readonly NamedNode[];
-    get descendantObjectTypes(): readonly NamedObjectType[];
+    get descendantObjectTypes(): readonly ObjectType[];
     get discriminantProperty(): Maybe<AbstractType.DiscriminantProperty>;
     get discriminantValue(): string;
     get equalsFunction(): Code;
+    get expression(): Code;
     get filterFunction(): Code;
     get filterType(): Code;
     get fromRdfTypeVariable(): Maybe<Code>;
@@ -57,9 +57,9 @@ export declare class NamedObjectType extends AbstractType {
     get hashFunction(): Code;
     get identifierTypeAlias(): Code;
     get mutable(): boolean;
-    get objectSetMethodNames(): NamedObjectType.ObjectSetMethodNames;
-    get parentObjectTypes(): readonly NamedObjectType[];
-    get properties(): readonly NamedObjectType.Property[];
+    get objectSetMethodNames(): ObjectType.ObjectSetMethodNames;
+    get parentObjectTypes(): readonly ObjectType[];
+    get properties(): readonly ObjectType.Property[];
     get schema(): Code;
     get schemaType(): Code;
     get toRdfResourceValueTypes(): AbstractType["toRdfResourceValueTypes"];
@@ -87,7 +87,7 @@ export declare class NamedObjectType extends AbstractType {
     private readonly lazyParentObjectTypes;
     private readonly lazyProperties;
 }
-export declare namespace NamedObjectType {
+export declare namespace ObjectType {
     const IdentifierProperty: typeof _IdentifierProperty;
     type IdentifierProperty = _IdentifierProperty;
     type ObjectSetMethodNames = {
@@ -102,4 +102,4 @@ export declare namespace NamedObjectType {
     const DiscriminantProperty: typeof _DiscriminantProperty;
     type DiscriminantProperty = _DiscriminantProperty;
 }
-//# sourceMappingURL=NamedObjectType.d.ts.map
+//# sourceMappingURL=ObjectType.d.ts.map