@shaclmate/compiler 4.0.8 → 4.0.10

package/dist/generators/ts/TypeFactory.js

@@ -2,11 +2,13 @@ import TermMap from "@rdfjs/term-map";
 import TermSet from "@rdfjs/term-set";
 import base62 from "@sindresorhus/base62";
 import { rdf, xsd } from "@tpluscode/rdf-ns-builders";
+import { Maybe } from "purify-ts";
 import { LiteralDecoder, literalDatatypeDefinitions } from "rdfjs-resource";
 import reservedTsIdentifiers_ from "reserved-identifiers";
 import { invariant } from "ts-invariant";
+import * as ast from "../../ast/index.js";
 import { logger } from "../../logger.js";
-import { codeName } from "../codeName.js";
+import { AnonymousUnionType } from "./AnonymousUnionType.js";
 import { BigDecimalType } from "./BigDecimalType.js";
 import { BigIntType } from "./BigIntType.js";
 import { BlankNodeType } from "./BlankNodeType.js";
@@ -23,31 +25,42 @@ import { LazyObjectSetType } from "./LazyObjectSetType.js";
 import { LazyObjectType } from "./LazyObjectType.js";
 import { ListType } from "./ListType.js";
 import { LiteralType } from "./LiteralType.js";
-import { ObjectType } from "./ObjectType.js";
-import { ObjectUnionType } from "./ObjectUnionType.js";
+import { NamedObjectType } from "./NamedObjectType.js";
+import { NamedObjectUnionType } from "./NamedObjectUnionType.js";
+import { NamedUnionType } from "./NamedUnionType.js";
 import { OptionType } from "./OptionType.js";
 import { SetType } from "./SetType.js";
 import { StringType } from "./StringType.js";
 import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { TermType } from "./TermType.js";
 import { code } from "./ts-poet-wrapper.js";
-import { UnionType } from "./UnionType.js";
-const reservedTsIdentifiers = reservedTsIdentifiers_({
-    includeGlobalProperties: true,
-});
-const tsName = codeName((value) => {
-    // Adapted from https://github.com/sindresorhus/to-valid-identifier , MIT license
-    if (reservedTsIdentifiers.has(value)) {
-        // We prefix with underscore to avoid any potential conflicts with the Base62 encoded string.
-        return `$_${value}$`;
-    }
-    return value.replaceAll(/\P{ID_Continue}/gu, (x) => `$${base62.encodeInteger(x.codePointAt(0))}$`);
-}, syntheticNamePrefix);
 export class TypeFactory {
+    cachedNamedObjectUnionTypesByShapeIdentifier = new TermMap();
     cachedObjectTypePropertiesByShapeIdentifier = new TermMap();
     cachedObjectTypesByShapeIdentifier = new TermMap();
-    cachedObjectUnionTypesByShapeIdentifier = new TermMap();
-    createObjectType(astType) {
+    createNamedObjectUnionType(astType) {
+        {
+            const cachedNamedObjectUnionType = this.cachedNamedObjectUnionTypesByShapeIdentifier.get(astType.shapeIdentifier);
+            if (cachedNamedObjectUnionType) {
+                return cachedNamedObjectUnionType;
+            }
+        }
+        const namedObjectUnionType = new NamedObjectUnionType({
+            comment: astType.comment,
+            features: astType.tsFeatures,
+            identifierType: this.createIdentifierType(ast.ObjectCompoundType.identifierType(astType)),
+            label: astType.label,
+            members: ast.ObjectCompoundType.memberObjectTypes(astType).map((namedObjectType) => ({
+                discriminantValue: Maybe.empty(),
+                type: this.createNamedObjectType(namedObjectType),
+            })),
+            name: tsName(astType.name.unsafeCoerce()),
+            recursive: astType.recursive,
+        });
+        this.cachedNamedObjectUnionTypesByShapeIdentifier.set(astType.shapeIdentifier, namedObjectUnionType);
+        return namedObjectUnionType;
+    }
+    createNamedObjectType(astType) {
         {
             const cachedObjectType = this.cachedObjectTypesByShapeIdentifier.get(astType.shapeIdentifier);
             if (cachedObjectType) {
@@ -55,25 +68,56 @@ export class TypeFactory {
             }
         }
         const identifierType = this.createIdentifierType(astType.identifierType);
-        const staticModuleName = astType.childObjectTypes.length > 0
-            ? `${tsName(astType)}Static`
-            : tsName(astType);
-        const objectType = new ObjectType({
+        const name = tsName(astType.name.unsafeCoerce(), {
+            synthetic: astType.synthetic,
+        });
+        const staticModuleName = astType.childObjectTypes.length > 0 ? `${name}Static` : name;
+        const namedObjectType = new NamedObjectType({
             abstract: astType.abstract,
             comment: astType.comment,
             declarationType: astType.tsObjectDeclarationType,
-            export_: astType.export,
             extern: astType.extern,
             features: astType.tsFeatures,
             fromRdfType: astType.fromRdfType,
             identifierType,
             imports: astType.tsImports,
             label: astType.label,
-            lazyAncestorObjectTypes: () => astType.ancestorObjectTypes.map((astType) => this.createObjectType(astType)),
-            lazyChildObjectTypes: () => astType.childObjectTypes.map((astType) => this.createObjectType(astType)),
-            lazyDescendantObjectTypes: () => astType.descendantObjectTypes.map((astType) => this.createObjectType(astType)),
-            lazyParentObjectTypes: () => astType.parentObjectTypes.map((astType) => this.createObjectType(astType)),
-            lazyProperties: (objectType) => {
+            lazyAncestorObjectTypes: () => astType.ancestorObjectTypes.map((astType) => this.createNamedObjectType(astType)),
+            lazyChildObjectTypes: () => astType.childObjectTypes.map((astType) => this.createNamedObjectType(astType)),
+            lazyDescendantObjectTypes: () => astType.descendantObjectTypes.map((astType) => this.createNamedObjectType(astType)),
+            lazyDiscriminantProperty: (namedObjectType) => {
+                // Discriminant property
+                const discriminantOwnValue = !astType.abstract
+                    ? namedObjectType.discriminantValue
+                    : undefined;
+                const discriminantDescendantValues = new Set();
+                for (const descendantObjectType of namedObjectType.descendantObjectTypes) {
+                    if (!descendantObjectType.abstract) {
+                        discriminantDescendantValues.add(descendantObjectType.discriminantValue);
+                    }
+                }
+                return new NamedObjectType.DiscriminantProperty({
+                    name: `${syntheticNamePrefix}type`,
+                    namedObjectType,
+                    type: new NamedObjectType.DiscriminantProperty.Type({
+                        descendantValues: [...discriminantDescendantValues].sort(),
+                        mutable: false,
+                        ownValues: discriminantOwnValue ? [discriminantOwnValue] : [],
+                    }),
+                    visibility: "public",
+                });
+            },
+            lazyIdentifierProperty: (namedObjectType) => new NamedObjectType.IdentifierProperty({
+                identifierMintingStrategy: astType.identifierMintingStrategy,
+                identifierPrefixPropertyName: `${syntheticNamePrefix}identifierPrefix`,
+                name: `${syntheticNamePrefix}identifier`,
+                namedObjectType,
+                type: identifierType,
+                typeAlias: code `${staticModuleName}.${syntheticNamePrefix}Identifier`,
+                visibility: "public",
+            }),
+            lazyParentObjectTypes: () => astType.parentObjectTypes.map((astType) => this.createNamedObjectType(astType)),
+            lazyProperties: (namedObjectType) => {
                 const properties = astType.properties
                     .toSorted((left, right) => {
                     if (left.order < right.order) {
@@ -82,43 +126,22 @@ export class TypeFactory {
                     if (left.order > right.order) {
                         return 1;
                     }
-                    return tsName(left).localeCompare(tsName(right));
+                    return tsName(left.name).localeCompare(tsName(right.name));
                 })
                     .map((astProperty) => this.createObjectTypeProperty({
                     astObjectTypeProperty: astProperty,
-                    objectType,
+                    namedObjectType,
                 }));
-                // Type discriminant property
-                const typeDiscriminantOwnValue = !astType.abstract
-                    ? objectType.discriminantValue
-                    : undefined;
-                const typeDiscriminantDescendantValues = new Set();
-                for (const descendantObjectType of objectType.descendantObjectTypes) {
-                    if (!descendantObjectType.abstract) {
-                        typeDiscriminantDescendantValues.add(descendantObjectType.discriminantValue);
-                    }
-                }
-                if (typeDiscriminantOwnValue ||
-                    typeDiscriminantDescendantValues.size > 0) {
-                    properties.splice(0, 0, new ObjectType.TypeDiscriminantProperty({
-                        name: `${syntheticNamePrefix}type`,
-                        objectType,
-                        type: new ObjectType.TypeDiscriminantProperty.Type({
-                            descendantValues: [...typeDiscriminantDescendantValues].sort(),
-                            mutable: false,
-                            ownValues: typeDiscriminantOwnValue
-                                ? [typeDiscriminantOwnValue]
-                                : [],
-                        }),
-                        visibility: "public",
-                    }));
+                if (namedObjectType._discriminantProperty.type.ownValues.length > 0 ||
+                    namedObjectType._discriminantProperty.type.descendantValues.length > 0) {
+                    properties.splice(0, 0, namedObjectType._discriminantProperty);
                 }
                 // Some ObjectTypes have an identifierPrefix property, depending on their identifier minting strategy.
-                if (objectTypeNeedsIdentifierPrefixProperty(astType)) {
-                    properties.splice(0, 0, new ObjectType.IdentifierPrefixProperty({
+                if (namedObjectTypeNeedsIdentifierPrefixProperty(astType)) {
+                    properties.splice(0, 0, new NamedObjectType.IdentifierPrefixProperty({
                         name: `${syntheticNamePrefix}identifierPrefix`,
-                        objectType,
-                        own: !astType.ancestorObjectTypes.some(objectTypeNeedsIdentifierPrefixProperty),
+                        namedObjectType,
+                        own: !astType.ancestorObjectTypes.some(namedObjectTypeNeedsIdentifierPrefixProperty),
                         type: new StringType({
                             comment: astType.comment,
                             datatype: xsd.string,
@@ -131,45 +154,18 @@ export class TypeFactory {
                         visibility: "protected",
                     }));
                 }
-                // Every ObjectType has an identifier property. Some are abstract.
-                properties.splice(0, 0, new ObjectType.IdentifierProperty({
-                    identifierMintingStrategy: astType.identifierMintingStrategy,
-                    identifierPrefixPropertyName: `${syntheticNamePrefix}identifierPrefix`,
-                    name: `${syntheticNamePrefix}identifier`,
-                    objectType,
-                    type: identifierType,
-                    typeAlias: code `${staticModuleName}.${syntheticNamePrefix}Identifier`,
-                    visibility: "public",
-                }));
+                // Every NamedObjectType has an identifier property. Some are abstract.
+                properties.splice(0, 0, namedObjectType.identifierProperty);
                 return properties;
             },
-            identifierMintingStrategy: astType.identifierMintingStrategy,
-            name: tsName(astType),
+            name,
+            recursive: astType.recursive,
             staticModuleName,
             synthetic: astType.synthetic,
             toRdfTypes: astType.toRdfTypes,
         });
-        this.cachedObjectTypesByShapeIdentifier.set(astType.shapeIdentifier, objectType);
-        return objectType;
-    }
-    createObjectUnionType(astType) {
-        {
-            const cachedObjectUnionType = this.cachedObjectUnionTypesByShapeIdentifier.get(astType.shapeIdentifier);
-            if (cachedObjectUnionType) {
-                return cachedObjectUnionType;
-            }
-        }
-        const objectUnionType = new ObjectUnionType({
-            comment: astType.comment,
-            export_: astType.export,
-            features: astType.tsFeatures,
-            identifierType: this.createIdentifierType(astType.identifierType),
-            label: astType.label,
-            memberTypes: astType.memberObjectTypes.map((objectType) => this.createObjectType(objectType)),
-            name: tsName(astType),
-        });
-        this.cachedObjectUnionTypesByShapeIdentifier.set(astType.shapeIdentifier, objectUnionType);
-        return objectUnionType;
+        this.cachedObjectTypesByShapeIdentifier.set(astType.shapeIdentifier, namedObjectType);
+        return namedObjectType;
     }
     createType(astType, parameters) {
         switch (astType.kind) {
@@ -193,16 +189,10 @@ export class TypeFactory {
                 return this.createListType(astType);
             case "LiteralType":
                 return this.createLiteralType(astType, parameters);
-            case "ObjectIntersectionType":
-                throw new Error("not implemented");
             case "ObjectType":
-                return this.createObjectType(astType);
-            case "ObjectUnionType":
-                return this.createObjectUnionType(astType);
+                return this.createNamedObjectType(astType);
             case "OptionType":
                 return this.createOptionType(astType);
-            case "PlaceholderType":
-                throw new Error(astType.kind);
             case "SetType":
                 return this.createSetType(astType);
             case "TermType":
@@ -211,6 +201,34 @@ export class TypeFactory {
                 return this.createUnionType(astType);
         }
     }
+    createUnionType(astType) {
+        if (astType.isObjectUnionType()) {
+            return this.createNamedObjectUnionType(astType);
+        }
+        return astType.name
+            .map((name) => new NamedUnionType({
+            comment: astType.comment,
+            features: astType.tsFeatures,
+            identifierType: Maybe.empty(),
+            label: astType.label,
+            members: astType.members.map((member) => ({
+                discriminantValue: member.discriminantValue,
+                type: this.createType(member.type),
+            })),
+            name,
+            recursive: astType.recursive,
+        }))
+            .orDefaultLazy(() => new AnonymousUnionType({
+            comment: astType.comment,
+            label: astType.label,
+            identifierType: Maybe.empty(),
+            members: astType.members.map((member) => ({
+                discriminantValue: member.discriminantValue,
+                type: this.createType(member.type),
+            })),
+            recursive: astType.recursive,
+        }));
+    }
     createBlankNodeType(astType) {
         return new BlankNodeType({
             comment: astType.comment,
@@ -401,21 +419,20 @@ export class TypeFactory {
             languageIn: astType.languageIn,
         });
     }
-    createObjectTypeProperty({ astObjectTypeProperty, objectType, }) {
+    createObjectTypeProperty({ astObjectTypeProperty, namedObjectType, }) {
         {
             const cachedProperty = this.cachedObjectTypePropertiesByShapeIdentifier.get(astObjectTypeProperty.shapeIdentifier);
             if (cachedProperty) {
                 return cachedProperty;
             }
         }
-        const name = tsName(astObjectTypeProperty);
-        const property = new ObjectType.ShaclProperty({
+        const property = new NamedObjectType.ShaclProperty({
             comment: astObjectTypeProperty.comment,
             description: astObjectTypeProperty.description,
             label: astObjectTypeProperty.label,
             mutable: astObjectTypeProperty.mutable,
-            objectType,
-            name,
+            namedObjectType,
+            name: tsName(astObjectTypeProperty.name),
             path: astObjectTypeProperty.path,
             recursive: !!astObjectTypeProperty.recursive,
             type: this.createType(astObjectTypeProperty.type),
@@ -453,17 +470,9 @@ export class TypeFactory {
             nodeKinds: astType.nodeKinds,
         });
     }
-    createUnionType(astType) {
-        return new UnionType({
-            comment: astType.comment,
-            label: astType.label,
-            memberDiscriminantValues: astType.memberDiscriminantValues,
-            memberTypes: astType.memberTypes.map((astType) => this.createType(astType)),
-        });
-    }
 }
-function objectTypeNeedsIdentifierPrefixProperty(objectType) {
-    return objectType.identifierMintingStrategy
+function namedObjectTypeNeedsIdentifierPrefixProperty(namedObjectType) {
+    return namedObjectType.identifierMintingStrategy
         .map((identifierMintingStrategy) => {
         switch (identifierMintingStrategy) {
             case "blankNode":
@@ -478,4 +487,22 @@ function objectTypeNeedsIdentifierPrefixProperty(objectType) {
     })
         .orDefault(false);
 }
+function tsName(name, options) {
+    if (name[0] === "$") {
+        return name;
+    }
+    // Adapted from https://github.com/sindresorhus/to-valid-identifier , MIT license
+    if (reservedTsIdentifiers.has(name)) {
+        // We prefix with underscore to avoid any potential conflicts with the Base62 encoded string.
+        return `$_${name}$`;
+    }
+    let tsName = name.replaceAll(/\P{ID_Continue}/gu, (x) => `$${base62.encodeInteger(x.codePointAt(0))}$`);
+    if (options?.synthetic) {
+        tsName = `${syntheticNamePrefix}${tsName}`;
+    }
+    return tsName;
+}
+const reservedTsIdentifiers = reservedTsIdentifiers_({
+    includeGlobalProperties: true,
+});
 //# sourceMappingURL=TypeFactory.js.map

package/dist/generators/ts/ZodGenerator.js

@@ -1,31 +1,33 @@
+import { invariant } from "ts-invariant";
 import * as ast from "../../ast/index.js";
-import { ObjectType_jsonTypeAliasDeclaration } from "./_ObjectType/ObjectType_jsonTypeAliasDeclaration.js";
-import { ObjectType_jsonZodSchemaFunctionDeclaration } from "./_ObjectType/ObjectType_jsonZodSchemaFunctionDeclaration.js";
-import { ObjectUnionType_jsonTypeAliasDeclaration } from "./_ObjectUnionType/ObjectUnionType_jsonTypeAliasDeclaration.js";
-import { ObjectUnionType_jsonZodSchemaFunctionDeclaration } from "./_ObjectUnionType/ObjectUnionType_jsonZodSchemaFunctionDeclaration.js";
+import { NamedObjectType_jsonSchemaFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_jsonSchemaFunctionDeclaration.js";
+import { NamedObjectType_jsonTypeAliasDeclaration } from "./_NamedObjectType/NamedObjectType_jsonTypeAliasDeclaration.js";
 import { snippets } from "./snippets.js";
+import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { TypeFactory } from "./TypeFactory.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 export class ZodGenerator {
     typeFactory = new TypeFactory();
     generate(ast_) {
         const declarations = [];
-        for (const objectType of ast.ObjectType.toposort(ast_.objectTypes).map((astObjectType) => this.typeFactory.createObjectType(astObjectType))) {
+        for (const namedObjectType of ast.ObjectType.toposort(ast_.namedObjectTypes).map((astObjectType) => this.typeFactory.createNamedObjectType(astObjectType))) {
             declarations.push(code `\
-export namespace ${objectType.staticModuleName} {
-${joinCode([
-                ...ObjectType_jsonTypeAliasDeclaration.bind(objectType)().toList(),
-                ...ObjectType_jsonZodSchemaFunctionDeclaration.bind(objectType)().toList(),
-            ], { on: "\n\n" })}
+export namespace ${namedObjectType.staticModuleName} {
+  ${joinCode(NamedObjectType_jsonTypeAliasDeclaration.bind(namedObjectType)().toList())}
+
+  export namespace ${syntheticNamePrefix}Json {
+    ${joinCode(NamedObjectType_jsonSchemaFunctionDeclaration.bind(namedObjectType)().toList())}
+  }
 }`);
         }
-        for (const objectUnionType of ast_.objectUnionTypes.map((astObjectUnionType) => this.typeFactory.createObjectUnionType(astObjectUnionType))) {
+        for (const astNamedUnionType of ast_.namedUnionTypes.map((astNamedUnionType) => this.typeFactory.createUnionType(astNamedUnionType))) {
+            invariant(astNamedUnionType.kind !== "AnonymousUnionType");
             declarations.push(code `\
-export namespace ${objectUnionType.staticModuleName} {
-${joinCode([
-                ...ObjectUnionType_jsonTypeAliasDeclaration.bind(objectUnionType)().toList(),
-                ...ObjectUnionType_jsonZodSchemaFunctionDeclaration.bind(objectUnionType)().toList(),
-            ], { on: "\n\n" })}
+export namespace ${astNamedUnionType.staticModuleName} {
+  ${astNamedUnionType.jsonTypeAliasDeclaration}
+  export namespace ${syntheticNamePrefix}Json {
+    ${astNamedUnionType.jsonSchemaFunctionDeclaration}
+  }
 }`);
         }
         declarations.splice(0, 0, joinCode(Object.values(snippets)

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

@@ -1,10 +1,10 @@
 import type { Maybe } from "purify-ts";
 import type { PropertyVisibility } from "../../../enums/PropertyVisibility.js";
-import type { ObjectType } from "../ObjectType.js";
+import type { NamedObjectType } from "../NamedObjectType.js";
 import type { Type } from "../Type.js";
 import { type Code } from "../ts-poet-wrapper.js";
 export declare abstract class AbstractProperty<TypeT extends Pick<Type, "filterFunction" | "mutable" | "name" | "schema">> {
-    protected readonly objectType: ObjectType;
+    protected readonly namedObjectType: NamedObjectType;
     /**
      * Optional property to include in the parameters object of a class constructor.
      */
@@ -47,7 +47,7 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "filterF
     /**
      * zod Object key: schema pair on the property serialized by toJsonObjectMember.
      */
-    abstract readonly jsonZodSchema: Maybe<{
+    abstract readonly jsonZchema: Maybe<{
         readonly key: string;
         readonly schema: Code;
     }>;
@@ -64,7 +64,7 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "filterF
      */
     readonly name: string;
     /**
-     * Is the property's type the ObjectType or does its type indirectly reference the ObjectType?
+     * Is the property's type the NamedObjectType or does its type indirectly reference the NamedObjectType?
      */
     abstract readonly recursive: boolean;
     /**
@@ -75,9 +75,9 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "filterF
      * Property visibility: private, protected, public.
      */
     readonly visibility: PropertyVisibility;
-    constructor({ name, objectType, type, visibility, }: {
+    constructor({ name, namedObjectType, type, visibility, }: {
         name: string;
-        objectType: ObjectType;
+        namedObjectType: NamedObjectType;
         type: TypeT;
         visibility: PropertyVisibility;
     });
@@ -109,7 +109,7 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "filterF
     /**
      * Expression to deserialize this property on the given rdfjsResource.Resource to a Either<Error, this property type>.
      */
-    abstract fromRdfExpression(parameters: {
+    abstract fromRdfResourceValuesExpression(parameters: {
         variables: {
             context: Code;
             graph: Code;
@@ -184,8 +184,8 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "filterF
     /**
      * Statements to serialize this property to an RDF resource.
      */
-    abstract toRdfStatements(parameters: {
-        variables: Omit<Parameters<Type["toRdfExpression"]>[0]["variables"], "propertyPath">;
+    abstract toRdfRdfResourceValuesStatements(parameters: {
+        variables: Omit<Parameters<Type["toRdfResourceValuesExpression"]>[0]["variables"], "propertyPath">;
     }): readonly Code[];
 }
 //# sourceMappingURL=AbstractProperty.d.ts.map

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

@@ -9,7 +9,7 @@ import { Memoize } from "typescript-memoize";
 import { removeUndefined } from "../removeUndefined.js";
 import { code, literalOf } from "../ts-poet-wrapper.js";
 export class AbstractProperty {
-    objectType;
+    namedObjectType;
     /**
      * TypeScript identifier-safe name of the property.
      */
@@ -22,9 +22,9 @@ export class AbstractProperty {
      * Property visibility: private, protected, public.
      */
     visibility;
-    constructor({ name, objectType, type, visibility, }) {
+    constructor({ name, namedObjectType, type, visibility, }) {
         this.name = name;
-        this.objectType = objectType;
+        this.namedObjectType = namedObjectType;
         this.type = type;
         this.visibility = visibility;
     }

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

@@ -1,35 +1,35 @@
 import { Maybe } from "purify-ts";
 import { type Code } from "../ts-poet-wrapper.js";
 import { AbstractProperty } from "./AbstractProperty.js";
-export declare class TypeDiscriminantProperty extends AbstractProperty<TypeDiscriminantProperty.Type> {
+export declare class DiscriminantProperty extends AbstractProperty<DiscriminantProperty.Type> {
     readonly constructorParametersSignature: Maybe<Code>;
     readonly equalsFunction: Maybe<Code>;
-    readonly filterProperty: AbstractProperty<TypeDiscriminantProperty.Type>["filterProperty"];
+    readonly filterProperty: AbstractProperty<DiscriminantProperty.Type>["filterProperty"];
     readonly getAccessorDeclaration: Maybe<Code>;
-    readonly graphqlField: AbstractProperty<TypeDiscriminantProperty.Type>["graphqlField"];
-    readonly kind = "TypeDiscriminantProperty";
+    readonly graphqlField: AbstractProperty<DiscriminantProperty.Type>["graphqlField"];
+    readonly kind = "DiscriminantProperty";
     readonly mutable = false;
     readonly recursive = false;
     constructor({ type, ...superParameters }: {
-        type: TypeDiscriminantProperty.Type;
+        type: DiscriminantProperty.Type;
     } & ConstructorParameters<typeof AbstractProperty>[0]);
     get declaration(): Maybe<Code>;
     get jsonSignature(): Maybe<Code>;
-    get jsonZodSchema(): AbstractProperty<TypeDiscriminantProperty.Type>["jsonZodSchema"];
+    get jsonZchema(): AbstractProperty<DiscriminantProperty.Type>["jsonZchema"];
     private get abstract();
     private get initializer();
     private get override();
     constructorStatements(): readonly Code[];
     fromJsonStatements(): readonly Code[];
-    fromRdfExpression(): Maybe<Code>;
-    hashStatements({ variables, }: Parameters<AbstractProperty<TypeDiscriminantProperty.Type>["hashStatements"]>[0]): readonly Code[];
-    jsonUiSchemaElement({ variables, }: Parameters<AbstractProperty<TypeDiscriminantProperty.Type>["jsonUiSchemaElement"]>[0]): Maybe<Code>;
+    fromRdfResourceValuesExpression(): Maybe<Code>;
+    hashStatements({ variables, }: Parameters<AbstractProperty<DiscriminantProperty.Type>["hashStatements"]>[0]): readonly Code[];
+    jsonUiSchemaElement({ variables, }: Parameters<AbstractProperty<DiscriminantProperty.Type>["jsonUiSchemaElement"]>[0]): Maybe<Code>;
     sparqlConstructTriplesExpression(): Maybe<Code>;
-    sparqlWherePatternsExpression(): ReturnType<AbstractProperty<TypeDiscriminantProperty.Type>["sparqlWherePatternsExpression"]>;
-    toJsonObjectMemberExpression({ variables, }: Parameters<AbstractProperty<TypeDiscriminantProperty.Type>["toJsonObjectMemberExpression"]>[0]): Maybe<Code>;
-    toRdfStatements(): readonly Code[];
+    sparqlWherePatternsExpression(): ReturnType<AbstractProperty<DiscriminantProperty.Type>["sparqlWherePatternsExpression"]>;
+    toJsonObjectMemberExpression({ variables, }: Parameters<AbstractProperty<DiscriminantProperty.Type>["toJsonObjectMemberExpression"]>[0]): Maybe<Code>;
+    toRdfRdfResourceValuesStatements(): readonly Code[];
 }
-export declare namespace TypeDiscriminantProperty {
+export declare namespace DiscriminantProperty {
     class Type {
         readonly filterFunction: Code;
         readonly mutable: boolean;
@@ -45,4 +45,4 @@ export declare namespace TypeDiscriminantProperty {
         get values(): string[];
     }
 }
-//# sourceMappingURL=TypeDiscriminantProperty.d.ts.map
+//# sourceMappingURL=DiscriminantProperty.d.ts.map