@shaclmate/compiler 2.0.18 → 2.0.19

package/dist/_ShapesGraphToAstTransformer/transformNodeShapeToAstType.js

@@ -150,6 +150,7 @@ export function transformNodeShapeToAstType(nodeShape) {
         parentObjectTypes: [], // This is mutable, we'll populate it below
         toRdfTypes: nodeShape.toRdfTypes,
         tsFeatures: nodeShape.tsFeatures.orDefault(new Set(TsFeature.MEMBERS)),
+        tsIdentifierPrefixPropertyName: nodeShape.tsObjectIdentifierPrefixPropertyName.orDefault("identifierPrefix"),
         tsIdentifierPropertyName: nodeShape.tsObjectIdentifierPropertyName.orDefault("identifier"),
         tsImports: nodeShape.tsImports,
         tsObjectDeclarationType: nodeShape.tsObjectDeclarationType.orDefault("class"),
@@ -177,6 +178,15 @@ export function transformNodeShapeToAstType(nodeShape) {
         }
         objectType.properties.push(propertyEither.unsafeCoerce());
     }
+    objectType.properties.sort((left, right) => {
+        if (left.order < right.order) {
+            return -1;
+        }
+        if (left.order > right.order) {
+            return 1;
+        }
+        return 0;
+    });
     return Either.of(objectType);
 }
 //# sourceMappingURL=transformNodeShapeToAstType.js.map

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstObjectTypeProperty.js

@@ -21,6 +21,7 @@ export function transformPropertyShapeToAstObjectTypeProperty(propertyShape) {
         label: pickLiteral(propertyShape.labels).map((literal) => literal.value),
         mutable: propertyShape.mutable,
         name: this.shapeAstName(propertyShape),
+        order: propertyShape.order.orDefault(0),
         path,
         type: type.extract(),
         visibility: propertyShape.visibility,

package/dist/ast/ObjectType.d.ts

@@ -103,6 +103,10 @@ export interface ObjectType {
      * TypeScript features to generate.
      */
     readonly tsFeatures: Set<TsFeature>;
+    /**
+     * Name of the identifier prefix property in TypeScript-generated classes/interfaces.
+     */
+    readonly tsIdentifierPrefixPropertyName: string;
     /**
      * Name of the identifier property in TypeScript-generated classes/interfaces.
      */
@@ -148,6 +152,10 @@ export declare namespace ObjectType {
          * Name of this property.
          */
         readonly name: Name;
+        /**
+         * Relative order of this property, derived from sh:order.
+         */
+        readonly order: number;
         /**
          * SHACL property path (https://www.w3.org/TR/shacl/#property-paths)
          */

package/dist/enums/IdentifierMintingStrategy.d.ts

@@ -1,5 +1,5 @@
 /**
  * TypeScript enum corresponding to shaclmate:identifierMintingStrategy, for simpler manipulation.
  */
-export type IdentifierMintingStrategy = "sha256" | "uuidv4";
+export type IdentifierMintingStrategy = "blankNode" | "sha256" | "uuidv4";
 //# sourceMappingURL=IdentifierMintingStrategy.d.ts.map

package/dist/generators/ts/ListType.js

@@ -15,8 +15,7 @@ export class ListType extends Type {
         super(superParameters);
         this.identifierNodeKind = identifierNodeKind;
         this.itemType = itemType;
-        this.identifierMintingStrategy =
-            identifierMintingStrategy.orDefault("sha256");
+        this.identifierMintingStrategy = identifierMintingStrategy.orDefault(identifierNodeKind === "BlankNode" ? "blankNode" : "sha256");
         this._mutable = mutable;
         this.toRdfTypes = toRdfTypes;
     }
@@ -230,6 +229,8 @@ export class ListType extends Type {
             }
             case "NamedNode": {
                 switch (this.identifierMintingStrategy) {
+                    case "blankNode":
+                        throw new RangeError(this.identifierMintingStrategy);
                     case "sha256":
                         listIdentifier = `dataFactory.namedNode(\`urn:shaclmate:list:\${${variables.value}.reduce(
         (_hasher, _item) => {

package/dist/generators/ts/ObjectType.d.ts

@@ -47,6 +47,7 @@ export declare class ObjectType extends DeclaredType {
     get discriminatorValue(): string;
     get equalsFunction(): string;
     get hashFunctionName(): string;
+    get hashShaclPropertiesFunctionName(): string;
     get identifierProperty(): ObjectType.IdentifierProperty;
     get identifierType(): IdentifierType;
     get jsonName(): string;
@@ -54,6 +55,7 @@ export declare class ObjectType extends DeclaredType {
     get jsonZodSchemaFunctionName(): string;
     get mutable(): boolean;
     get ownProperties(): readonly ObjectType.Property[];
+    get ownShaclProperties(): readonly ObjectType.Property[];
     get parentObjectTypes(): readonly ObjectType[];
     get properties(): readonly ObjectType.Property[];
     protected get thisVariable(): string;
@@ -82,6 +84,8 @@ export declare class ObjectType extends DeclaredType {
     protected ensureAtMostOneSuperObjectType(): void;
 }
 export declare namespace ObjectType {
+    const IdentifierPrefixProperty: typeof _ObjectType.IdentifierPrefixProperty;
+    type IdentifierPrefixProperty = _ObjectType.IdentifierPrefixProperty;
     const IdentifierProperty: typeof _ObjectType.IdentifierProperty;
     type IdentifierProperty = _ObjectType.IdentifierProperty;
     const Property: typeof _ObjectType.Property;

package/dist/generators/ts/ObjectType.js

@@ -13,7 +13,6 @@ import { DeclaredType } from "./DeclaredType.js";
 import { Import } from "./Import.js";
 import { SnippetDeclarations } from "./SnippetDeclarations.js";
 import * as _ObjectType from "./_ObjectType/index.js";
-import { IdentifierProperty, TypeDiscriminatorProperty, } from "./_ObjectType/index.js";
 import { objectInitializer } from "./objectInitializer.js";
 export class ObjectType extends DeclaredType {
     abstract;
@@ -101,7 +100,7 @@ export class ObjectType extends DeclaredType {
             ..._ObjectType.jsonSchemaFunctionDeclaration.bind(this)().toList(),
             ..._ObjectType.jsonUiSchemaFunctionDeclaration.bind(this)().toList(),
             ..._ObjectType.jsonZodSchemaFunctionDeclaration.bind(this)().toList(),
-            ..._ObjectType.hashFunctionDeclaration.bind(this)().toList(),
+            ..._ObjectType.hashFunctionDeclarations.bind(this)(),
             ..._ObjectType.sparqlFunctionDeclarations.bind(this)(),
             ..._ObjectType.toJsonFunctionDeclaration.bind(this)().toList(),
             ..._ObjectType.toRdfFunctionDeclaration.bind(this)().toList(),
@@ -141,6 +140,12 @@ export class ObjectType extends DeclaredType {
             return `hash${this.name}`;
         return "hash";
     }
+    get hashShaclPropertiesFunctionName() {
+        if (this.ancestorObjectTypes.length > 0 ||
+            this.descendantObjectTypes.length > 0)
+            return `_hash${this.name}ShaclProperties`;
+        return "_hashShaclProperties";
+    }
     get identifierProperty() {
         const identifierProperty = this.properties.find((property) => property instanceof ObjectType.IdentifierProperty);
         invariant(identifierProperty);
@@ -187,16 +192,16 @@ export class ObjectType extends DeclaredType {
             invariant(this.properties.length >= 2, this.name);
             return this.properties;
         }
-        return this.properties.filter((property) => !(property instanceof IdentifierProperty) &&
-            !(property instanceof TypeDiscriminatorProperty));
+        return this.ownShaclProperties;
+    }
+    get ownShaclProperties() {
+        return this.properties.filter((property) => property instanceof _ObjectType.ShaclProperty);
     }
     get parentObjectTypes() {
         return this.lazyParentObjectTypes();
     }
     get properties() {
-        const properties = this.lazyProperties()
-            .concat()
-            .sort((left, right) => left.name.localeCompare(right.name));
+        const properties = this.lazyProperties();
         const propertyNames = new Set();
         for (const property of properties) {
             if (propertyNames.has(property.name)) {
@@ -319,37 +324,71 @@ export class ObjectType extends DeclaredType {
         }
     }
 }
+__decorate([
+    Memoize()
+], ObjectType.prototype, "_discriminatorProperty", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "ancestorObjectTypes", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "conversions", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "declarationImports", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "descendantObjectTypes", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "discriminatorProperty", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "discriminatorValue", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "equalsFunction", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "hashFunctionName", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "hashShaclPropertiesFunctionName", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "identifierProperty", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "identifierType", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "jsonName", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "jsonUiSchemaFunctionName", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "jsonZodSchemaFunctionName", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "mutable", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "ownProperties", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "ownShaclProperties", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "parentObjectTypes", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "properties", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "thisVariable", null);
 (function (ObjectType) {
+    ObjectType.IdentifierPrefixProperty = _ObjectType.IdentifierPrefixProperty;
     ObjectType.IdentifierProperty = _ObjectType.IdentifierProperty;
     ObjectType.Property = _ObjectType.Property;
     ObjectType.ShaclProperty = _ObjectType.ShaclProperty;

package/dist/generators/ts/ObjectUnionType.js

@@ -10,7 +10,7 @@ import { invariant } from "ts-invariant";
 import { StructureKind, } from "ts-morph";
 import { Memoize } from "typescript-memoize";
 import { DeclaredType } from "./DeclaredType.js";
-import { hasherTypeConstraint } from "./_ObjectType/hashFunctionOrMethodDeclaration.js";
+import { hasherTypeConstraint } from "./_ObjectType/hashFunctionOrMethodDeclarations.js";
 import { sparqlConstructQueryFunctionDeclaration } from "./_ObjectType/sparqlConstructQueryFunctionDeclaration.js";
 import { sparqlConstructQueryStringFunctionDeclaration } from "./_ObjectType/sparqlConstructQueryStringFunctionDeclaration.js";
 import { objectInitializer } from "./objectInitializer.js";

package/dist/generators/ts/TypeFactory.js

@@ -19,6 +19,19 @@ import { StringType } from "./StringType.js";
 import { TermType } from "./TermType.js";
 import { UnionType } from "./UnionType.js";
 import { tsName } from "./tsName.js";
+function objectTypeNeedsIdentifierPrefixProperty(objectType) {
+    return objectType.identifierMintingStrategy
+        .map((identifierMintingStrategy) => {
+        switch (identifierMintingStrategy) {
+            case "blankNode":
+                return false;
+            case "sha256":
+            case "uuidv4":
+                return true;
+        }
+    })
+        .orDefault(false);
+}
 export class TypeFactory {
     cachedObjectTypePropertiesByIdentifier = new TermMap();
     cachedObjectTypesByIdentifier = new TermMap();
@@ -235,39 +248,18 @@ export class TypeFactory {
             lazyDescendantObjectTypes: () => astType.descendantObjectTypes.map((astType) => this.createObjectTypeFromAstType(astType)),
             lazyParentObjectTypes: () => astType.parentObjectTypes.map((astType) => this.createObjectTypeFromAstType(astType)),
             lazyProperties: () => {
-                const properties = astType.properties.map((astProperty) => this.createObjectTypePropertyFromAstProperty(astType, astProperty));
-                let identifierPropertyClassDeclarationVisibility;
-                if (astType.abstract) {
-                    // If the type is abstract, don't declare a property.
-                    identifierPropertyClassDeclarationVisibility = Maybe.empty();
-                }
-                else if (astType.ancestorObjectTypes.some((ancestorObjectType) => !ancestorObjectType.abstract)) {
-                    // If the type has a non-abstract ancestor, that ancestor will declare the identifier property
-                    identifierPropertyClassDeclarationVisibility = Maybe.empty();
-                }
-                else if (astType.descendantObjectTypes.some((descendantObjectType) => !descendantObjectType.abstract)) {
-                    // If the type has a non-abstract descendant, declare the identifier property for it
-                    identifierPropertyClassDeclarationVisibility = Maybe.of("protected");
-                }
-                else {
-                    identifierPropertyClassDeclarationVisibility = Maybe.of("private");
-                }
-                const identifierProperty = new ObjectType.IdentifierProperty({
-                    abstract: astType.abstract,
-                    classDeclarationVisibility: identifierPropertyClassDeclarationVisibility,
-                    dataFactoryVariable: this.dataFactoryVariable,
-                    identifierMintingStrategy: astType.identifierMintingStrategy,
-                    name: astType.tsIdentifierPropertyName,
-                    lazyObjectTypeMutable: () => properties.some((property) => property.mutable || property.type.mutable),
-                    objectType: {
-                        declarationType: astType.tsObjectDeclarationType,
-                        features: astType.tsFeatures,
-                    },
-                    override: astType.parentObjectTypes.length > 0,
-                    type: identifierType,
-                    visibility: "public",
-                });
-                properties.push(identifierProperty);
+                const properties = astType.properties
+                    .toSorted((left, right) => {
+                    if (left.order < right.order) {
+                        return -1;
+                    }
+                    if (left.order > right.order) {
+                        return 1;
+                    }
+                    return tsName(left.name).localeCompare(tsName(right.name));
+                })
+                    .map((astProperty) => this.createObjectTypePropertyFromAstProperty(astType, astProperty));
+                const lazyMutable = () => properties.some((property) => property.mutable || property.type.mutable);
                 // Type discriminator property
                 const typeDiscriminatorValues = new Set();
                 if (!astType.abstract) {
@@ -279,13 +271,14 @@ export class TypeFactory {
                     }
                 }
                 if (typeDiscriminatorValues.size > 0) {
-                    properties.push(new ObjectType.TypeDiscriminatorProperty({
+                    properties.splice(0, 0, new ObjectType.TypeDiscriminatorProperty({
                         abstract: astType.abstract,
                         dataFactoryVariable: this.dataFactoryVariable,
                         name: astType.tsTypeDiscriminatorPropertyName,
                         objectType: {
                             declarationType: astType.tsObjectDeclarationType,
                             features: astType.tsFeatures,
+                            mutable: lazyMutable,
                         },
                         override: objectType.parentObjectTypes.length > 0,
                         type: new ObjectType.TypeDiscriminatorProperty.Type({
@@ -296,7 +289,60 @@ export class TypeFactory {
                         value: objectType.discriminatorValue,
                     }));
                 }
-                return properties.sort((left, right) => left.name.localeCompare(right.name));
+                // Some ObjectTypes have an identifierPrefix property, depending on their identifier minting strategy.
+                if (objectTypeNeedsIdentifierPrefixProperty(astType)) {
+                    properties.splice(0, 0, new ObjectType.IdentifierPrefixProperty({
+                        dataFactoryVariable: this.dataFactoryVariable,
+                        own: !astType.ancestorObjectTypes.some(objectTypeNeedsIdentifierPrefixProperty),
+                        name: astType.tsIdentifierPrefixPropertyName,
+                        objectType: {
+                            declarationType: astType.tsObjectDeclarationType,
+                            features: astType.tsFeatures,
+                            mutable: lazyMutable,
+                        },
+                        type: new StringType({
+                            dataFactoryVariable: this.dataFactoryVariable,
+                            defaultValue: Maybe.empty(),
+                            hasValues: [],
+                            in_: [],
+                            languageIn: [],
+                            primitiveDefaultValue: Maybe.empty(),
+                            primitiveIn: [],
+                        }),
+                        visibility: "protected",
+                    }));
+                }
+                // Every ObjectType has an identifier property. Some are abstract.
+                properties.splice(0, 0, new ObjectType.IdentifierProperty({
+                    abstract: astType.abstract,
+                    classDeclarationVisibility: (() => {
+                        if (astType.abstract) {
+                            // If the type is abstract, don't declare an identifier property.
+                            return Maybe.empty();
+                        }
+                        if (astType.ancestorObjectTypes.some((ancestorObjectType) => !ancestorObjectType.abstract)) {
+                            // If the type has a non-abstract ancestor, that ancestor will declare the identifier property.
+                            return Maybe.empty();
+                        }
+                        if (astType.descendantObjectTypes.some((descendantObjectType) => !descendantObjectType.abstract)) {
+                            // If the type has a non-abstract descendant, declare the identifier property for it.
+                            return Maybe.of("protected");
+                        }
+                        return Maybe.of("private");
+                    })(),
+                    dataFactoryVariable: this.dataFactoryVariable,
+                    identifierMintingStrategy: astType.identifierMintingStrategy,
+                    name: astType.tsIdentifierPropertyName,
+                    objectType: {
+                        declarationType: astType.tsObjectDeclarationType,
+                        features: astType.tsFeatures,
+                        mutable: lazyMutable,
+                    },
+                    override: astType.parentObjectTypes.length > 0,
+                    type: identifierType,
+                    visibility: "public",
+                }));
+                return properties;
             },
             identifierMintingStrategy: astType.identifierMintingStrategy,
             name: tsName(astType.name),
@@ -321,6 +367,9 @@ export class TypeFactory {
             objectType: {
                 declarationType: astObjectType.tsObjectDeclarationType,
                 features: astObjectType.tsFeatures,
+                mutable: () => {
+                    throw new Error("not implemented");
+                },
             },
             name: tsName(astObjectTypeProperty.name),
             path: astObjectTypeProperty.path.iri,

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

@@ -0,0 +1,34 @@
+import type { IdentifierType } from "generators/ts/IdentifierType.js";
+import type { Import } from "generators/ts/Import.js";
+import { Maybe } from "purify-ts";
+import { type GetAccessorDeclarationStructure, type OptionalKind, type PropertyDeclarationStructure, type PropertySignatureStructure } from "ts-morph";
+import type { StringType } from "../StringType.js";
+import { Property } from "./Property.js";
+export declare class IdentifierPrefixProperty extends Property<StringType> {
+    readonly equalsFunction = "strictEquals";
+    readonly mutable = false;
+    private readonly own;
+    constructor({ own, ...superParameters }: {
+        own: boolean;
+        type: StringType;
+    } & ConstructorParameters<typeof Property>[0]);
+    get classGetAccessorDeclaration(): Maybe<OptionalKind<GetAccessorDeclarationStructure>>;
+    get classPropertyDeclaration(): Maybe<OptionalKind<PropertyDeclarationStructure>>;
+    get constructorParametersPropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
+    get declarationImports(): readonly Import[];
+    get interfacePropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
+    get jsonPropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
+    get snippetDeclarations(): readonly string[];
+    classConstructorStatements({ variables, }: Parameters<Property<IdentifierType>["classConstructorStatements"]>[0]): readonly string[];
+    fromJsonStatements(): readonly string[];
+    fromRdfStatements(): readonly string[];
+    hashStatements(): readonly string[];
+    interfaceConstructorStatements(): readonly string[];
+    jsonUiSchemaElement(): Maybe<string>;
+    jsonZodSchema(): ReturnType<Property<IdentifierType>["jsonZodSchema"]>;
+    sparqlConstructTemplateTriples(): readonly string[];
+    sparqlWherePatterns(): readonly string[];
+    toJsonObjectMember(): Maybe<string>;
+    toRdfStatements(): readonly string[];
+}
+//# sourceMappingURL=IdentifierPrefixProperty.d.ts.map

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

@@ -0,0 +1,98 @@
+import { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
+import { Scope, } from "ts-morph";
+import { SnippetDeclarations } from "../SnippetDeclarations.js";
+import { Property } from "./Property.js";
+export class IdentifierPrefixProperty extends Property {
+    equalsFunction = "strictEquals";
+    mutable = false;
+    own;
+    constructor({ own, ...superParameters }) {
+        super(superParameters);
+        invariant(this.visibility === "protected");
+        this.own = own;
+    }
+    get classGetAccessorDeclaration() {
+        return Maybe.of({
+            leadingTrivia: `protected ${!this.own ? "override " : ""}`,
+            name: this.name,
+            returnType: this.type.name,
+            statements: [
+                `return (typeof this._${this.name} !== "undefined") ? this._${this.name} : \`urn:shaclmate:\${this.type}:\``,
+            ],
+        });
+    }
+    get classPropertyDeclaration() {
+        return this.own
+            ? Maybe.of({
+                hasQuestionToken: true,
+                isReadonly: true,
+                name: `_${this.name}`,
+                scope: Scope.Protected,
+                type: this.type.name,
+            })
+            : Maybe.empty();
+    }
+    get constructorParametersPropertySignature() {
+        return Maybe.of({
+            hasQuestionToken: true,
+            isReadonly: true,
+            name: this.name,
+            type: this.type.name,
+        });
+    }
+    get declarationImports() {
+        return [];
+    }
+    get interfacePropertySignature() {
+        return Maybe.empty();
+    }
+    get jsonPropertySignature() {
+        return Maybe.empty();
+    }
+    get snippetDeclarations() {
+        const snippetDeclarations = [];
+        if (this.objectType.features.has("equals")) {
+            snippetDeclarations.push(SnippetDeclarations.strictEquals);
+        }
+        return snippetDeclarations;
+    }
+    classConstructorStatements({ variables, }) {
+        return this.classPropertyDeclaration
+            .map((classPropertyDeclaration) => [
+            `this.${classPropertyDeclaration.name} = ${variables.parameter};`,
+        ])
+            .orDefault([]);
+    }
+    fromJsonStatements() {
+        return [];
+    }
+    fromRdfStatements() {
+        return [];
+    }
+    hashStatements() {
+        return [];
+    }
+    interfaceConstructorStatements() {
+        return [];
+    }
+    jsonUiSchemaElement() {
+        return Maybe.empty();
+    }
+    jsonZodSchema() {
+        return Maybe.empty();
+    }
+    sparqlConstructTemplateTriples() {
+        return [];
+    }
+    sparqlWherePatterns() {
+        return [];
+    }
+    toJsonObjectMember() {
+        return Maybe.empty();
+    }
+    toRdfStatements() {
+        return [];
+    }
+}
+//# sourceMappingURL=IdentifierPrefixProperty.js.map

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

@@ -10,12 +10,10 @@ export declare class IdentifierProperty extends Property<IdentifierType> {
     readonly mutable = false;
     private readonly classDeclarationVisibility;
     private readonly identifierMintingStrategy;
-    private readonly lazyObjectTypeMutable;
     private readonly override;
-    constructor({ abstract, classDeclarationVisibility, lazyObjectTypeMutable, identifierMintingStrategy, override, ...superParameters }: {
+    constructor({ abstract, classDeclarationVisibility, identifierMintingStrategy, override, ...superParameters }: {
         abstract: boolean;
         classDeclarationVisibility: Maybe<PropertyVisibility>;
-        lazyObjectTypeMutable: () => boolean;
         identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
         override: boolean;
         type: IdentifierType;
@@ -24,8 +22,8 @@ export declare class IdentifierProperty extends Property<IdentifierType> {
     get classPropertyDeclaration(): Maybe<OptionalKind<PropertyDeclarationStructure>>;
     get constructorParametersPropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
     get declarationImports(): readonly Import[];
-    get interfacePropertySignature(): OptionalKind<PropertySignatureStructure>;
-    get jsonPropertySignature(): OptionalKind<PropertySignatureStructure>;
+    get interfacePropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
+    get jsonPropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
     get snippetDeclarations(): readonly string[];
     classConstructorStatements({ variables, }: Parameters<Property<IdentifierType>["classConstructorStatements"]>[0]): readonly string[];
     fromJsonStatements({ variables, }: Parameters<Property<IdentifierType>["fromJsonStatements"]>[0]): readonly string[];
@@ -36,7 +34,7 @@ export declare class IdentifierProperty extends Property<IdentifierType> {
     jsonZodSchema({ variables, }: Parameters<Property<IdentifierType>["jsonZodSchema"]>[0]): ReturnType<Property<IdentifierType>["jsonZodSchema"]>;
     sparqlConstructTemplateTriples(): readonly string[];
     sparqlWherePatterns(): readonly string[];
-    toJsonObjectMember({ variables, }: Parameters<Property<IdentifierType>["toJsonObjectMember"]>[0]): string;
+    toJsonObjectMember({ variables, }: Parameters<Property<IdentifierType>["toJsonObjectMember"]>[0]): Maybe<string>;
     toRdfStatements(): readonly string[];
 }
 //# sourceMappingURL=IdentifierProperty.d.ts.map