@shaclmate/compiler 4.0.23 → 4.0.24

package/dist/generators/ts/ListType.js

@@ -12,14 +12,12 @@ import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
 import { snippets } from "./snippets.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 export class ListType extends AbstractCollectionType {
-    identifierMintingStrategy;
     identifierNodeKind;
     toRdfTypes;
     kind = "ListType";
-    constructor({ identifierNodeKind, identifierMintingStrategy, toRdfTypes, ...superParameters }) {
+    constructor({ identifierNodeKind, toRdfTypes, ...superParameters }) {
         super(superParameters);
         this.identifierNodeKind = identifierNodeKind;
-        this.identifierMintingStrategy = identifierMintingStrategy.orDefault(identifierNodeKind === "BlankNode" ? "blankNode" : "sha256");
         this.toRdfTypes = toRdfTypes;
     }
     get valueSparqlConstructTriplesFunction() {
@@ -48,43 +46,26 @@ export class ListType extends AbstractCollectionType {
         return new AbstractCollectionType.JsonType(code `${!this.mutable ? "readonly " : ""}(${this.itemType.jsonType().name})[]`);
     }
     toRdfResourceValuesExpression({ variables, }) {
-        let listIdentifier;
+        let mintListIdentifierFunction;
+        let mintSubListIdentifierFunction;
         let resourceTypeName;
-        let subListIdentifier;
         switch (this.identifierNodeKind) {
             case "BlankNode": {
-                listIdentifier =
-                    subListIdentifier = code `${imports.dataFactory}.blankNode()`;
+                mintListIdentifierFunction =
+                    mintSubListIdentifierFunction = code `(() => ${imports.dataFactory}.blankNode())`;
                 resourceTypeName = code `${imports.Resource}<${imports.BlankNode}>`;
                 break;
             }
             case "IRI": {
-                switch (this.identifierMintingStrategy) {
-                    case "blankNode":
-                        throw new RangeError(this.identifierMintingStrategy);
-                    case "sha256":
-                        listIdentifier = code `${imports.dataFactory}.namedNode(\`urn:shaclmate:list:\${${variables.value}.reduce(
-        (hasher, item) => {
-          ${joinCode(this.itemType.hashStatements({ depth: 0, variables: { hasher: code `hasher`, value: code `item` } }).concat())}
-          return hasher;
-        },
-        ${imports.sha256}.create(),
-      )}\`)`;
-                        break;
-                    case "uuidv4":
-                        listIdentifier = code `${imports.dataFactory}.namedNode(\`urn:shaclmate:list:\${${imports.uuid}.v4()}\`)`;
-                        break;
-                }
                 resourceTypeName = code `${imports.Resource}<${imports.NamedNode}>`;
-                subListIdentifier = code `${imports.dataFactory}.namedNode(\`\${listResource.identifier.value}:\${itemIndex}\`)`;
-                break;
+                throw new RangeError("list IRI minting is unsupported");
             }
         }
         return code `[${variables.value}.length > 0 ? ${variables.value}.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
     if (itemIndex === 0) {
       currentSubListResource = listResource;
     } else {
-      const newSubListResource = ${variables.resourceSet}.resource(${subListIdentifier});
+      const newSubListResource = ${variables.resourceSet}.resource(${mintSubListIdentifierFunction}());
       currentSubListResource!.add(${rdfjsTermExpression(rdf.rest, { logger: this.logger })}, newSubListResource.identifier, ${variables.graph});
       currentSubListResource = newSubListResource;
     }
@@ -101,7 +82,7 @@ export class ListType extends AbstractCollectionType {
   },
   {
     currentSubListResource: null,
-    listResource: resourceSet.resource(${listIdentifier}),
+    listResource: resourceSet.resource(${mintListIdentifierFunction}()),
   } as {
     currentSubListResource: ${resourceTypeName} | null;
     listResource: ${resourceTypeName};

package/dist/generators/ts/NamedObjectType.d.ts

@@ -3,7 +3,6 @@ import { Maybe, NonEmptyList } from "purify-ts";
 import type { TsFeature } from "../../enums/TsFeature.js";
 import type { TsObjectDeclarationType } from "../../enums/TsObjectDeclarationType.js";
 import { DiscriminantProperty as _DiscriminantProperty } from "./_NamedObjectType/DiscriminantProperty.js";
-import { IdentifierPrefixProperty as _IdentifierPrefixProperty } from "./_NamedObjectType/IdentifierPrefixProperty.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";
@@ -29,7 +28,7 @@ export declare class NamedObjectType extends AbstractType {
     readonly staticModuleName: string;
     readonly synthetic: boolean;
     readonly typeofs: NonEmptyList<"object">;
-    constructor({ abstract, declarationType, extern, features, fromRdfType, identifierType, imports, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyDiscriminantProperty, lazyIdentifierProperty, lazyParentObjectTypes, lazyProperties, name, recursive, staticModuleName, synthetic, toRdfTypes, ...superParameters }: {
+    constructor({ abstract, declarationType, extern, features, fromRdfType, identifierType, imports, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyDiscriminantProperty, lazyParentObjectTypes, lazyProperties, name, recursive, staticModuleName, synthetic, toRdfTypes, ...superParameters }: {
         abstract: boolean;
         comment: Maybe<string>;
         declarationType: TsObjectDeclarationType;
@@ -42,7 +41,6 @@ export declare class NamedObjectType extends AbstractType {
         lazyAncestorObjectTypes: () => readonly NamedObjectType[];
         lazyChildObjectTypes: () => readonly NamedObjectType[];
         lazyDiscriminantProperty: (namedObjectType: NamedObjectType) => NamedObjectType.DiscriminantProperty;
-        lazyIdentifierProperty: (namedObjectType: NamedObjectType) => NamedObjectType.IdentifierProperty;
         lazyDescendantObjectTypes: () => readonly NamedObjectType[];
         lazyParentObjectTypes: () => readonly NamedObjectType[];
         lazyProperties: (namedObjectType: NamedObjectType) => readonly NamedObjectType.Property[];
@@ -67,12 +65,9 @@ export declare class NamedObjectType extends AbstractType {
     get filterType(): Code;
     get fromRdfTypeVariable(): Maybe<Code>;
     get graphqlType(): AbstractType.GraphqlType;
-    get identifierProperty(): NamedObjectType.IdentifierProperty;
     get identifierTypeAlias(): Code;
     get mutable(): boolean;
     get objectSetMethodNames(): NamedObjectType.ObjectSetMethodNames;
-    get ownProperties(): readonly NamedObjectType.Property[];
-    get ownShaclProperties(): readonly NamedObjectType.ShaclProperty<Type>[];
     get parentObjectTypes(): readonly NamedObjectType[];
     get properties(): readonly NamedObjectType.Property[];
     get schema(): Code;
@@ -104,13 +99,10 @@ export declare class NamedObjectType extends AbstractType {
     private readonly lazyChildObjectTypes;
     private readonly lazyDescendantObjectTypes;
     private readonly lazyDiscriminantProperty;
-    private readonly lazyIdentifierProperty;
     private readonly lazyParentObjectTypes;
     private readonly lazyProperties;
 }
 export declare namespace NamedObjectType {
-    const IdentifierPrefixProperty: typeof _IdentifierPrefixProperty;
-    type IdentifierPrefixProperty = _IdentifierPrefixProperty;
     const IdentifierProperty: typeof _IdentifierProperty;
     type IdentifierProperty = _IdentifierProperty;
     type ObjectSetMethodNames = {

package/dist/generators/ts/NamedObjectType.js

@@ -9,7 +9,6 @@ import { camelCase } from "change-case";
 import { Maybe, NonEmptyList } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { DiscriminantProperty as _DiscriminantProperty } from "./_NamedObjectType/DiscriminantProperty.js";
-import { IdentifierPrefixProperty as _IdentifierPrefixProperty } from "./_NamedObjectType/IdentifierPrefixProperty.js";
 import { IdentifierProperty as _IdentifierProperty } from "./_NamedObjectType/IdentifierProperty.js";
 import { identifierTypeDeclarations } from "./_NamedObjectType/identifierTypeDeclarations.js";
 import { NamedObjectType_classDeclaration } from "./_NamedObjectType/NamedObjectType_classDeclaration.js";
@@ -63,7 +62,7 @@ export class NamedObjectType extends AbstractType {
     staticModuleName;
     synthetic;
     typeofs = NonEmptyList(["object"]);
-    constructor({ abstract, declarationType, extern, features, fromRdfType, identifierType, imports, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyDiscriminantProperty, lazyIdentifierProperty, lazyParentObjectTypes, lazyProperties, name, recursive, staticModuleName, synthetic, toRdfTypes, ...superParameters }) {
+    constructor({ abstract, declarationType, extern, features, fromRdfType, identifierType, imports, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyDiscriminantProperty, lazyParentObjectTypes, lazyProperties, name, recursive, staticModuleName, synthetic, toRdfTypes, ...superParameters }) {
         super(superParameters);
         this.abstract = abstract;
         this.declarationType = declarationType;
@@ -77,7 +76,6 @@ export class NamedObjectType extends AbstractType {
         this.lazyChildObjectTypes = lazyChildObjectTypes;
         this.lazyDescendantObjectTypes = lazyDescendantObjectTypes;
         this.lazyDiscriminantProperty = lazyDiscriminantProperty;
-        this.lazyIdentifierProperty = lazyIdentifierProperty;
         this.lazyParentObjectTypes = lazyParentObjectTypes;
         this.lazyProperties = lazyProperties;
         this.name = name;
@@ -189,9 +187,6 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
     get graphqlType() {
         return new AbstractType.GraphqlType(code `${this.staticModuleName}.${syntheticNamePrefix}GraphQL`);
     }
-    get identifierProperty() {
-        return this.lazyIdentifierProperty(this);
-    }
     get identifierTypeAlias() {
         return code `${this.staticModuleName}.${syntheticNamePrefix}Identifier`;
     }
@@ -201,18 +196,6 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
     get objectSetMethodNames() {
         return NamedObjectType_objectSetMethodNames.call(this);
     }
-    get ownProperties() {
-        if (this.parentObjectTypes.length === 0) {
-            // 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);
-            return this.properties;
-        }
-        return this.ownShaclProperties;
-    }
-    get ownShaclProperties() {
-        return this.properties.filter((property) => property.kind === "ShaclProperty");
-    }
     get parentObjectTypes() {
         return this.lazyParentObjectTypes();
     }
@@ -335,7 +318,6 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
     lazyChildObjectTypes;
     lazyDescendantObjectTypes;
     lazyDiscriminantProperty;
-    lazyIdentifierProperty;
     lazyParentObjectTypes;
     lazyProperties;
 }
@@ -381,9 +363,6 @@ __decorate([
 __decorate([
     Memoize()
 ], NamedObjectType.prototype, "graphqlType", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "identifierProperty", null);
 __decorate([
     Memoize()
 ], NamedObjectType.prototype, "identifierTypeAlias", null);
@@ -393,12 +372,6 @@ __decorate([
 __decorate([
     Memoize()
 ], NamedObjectType.prototype, "objectSetMethodNames", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "ownProperties", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "ownShaclProperties", null);
 __decorate([
     Memoize()
 ], NamedObjectType.prototype, "parentObjectTypes", null);
@@ -430,7 +403,6 @@ __decorate([
     Memoize()
 ], NamedObjectType.prototype, "jsonType", null);
 (function (NamedObjectType) {
-    NamedObjectType.IdentifierPrefixProperty = _IdentifierPrefixProperty;
     NamedObjectType.IdentifierProperty = _IdentifierProperty;
     NamedObjectType.ShaclProperty = _ShaclProperty;
     NamedObjectType.DiscriminantProperty = _DiscriminantProperty;

package/dist/generators/ts/NamedObjectUnionType.js

@@ -142,7 +142,7 @@ export namespace ${syntheticNamePrefix}Identifier {
     get schemaVariableStatement() {
         const commonPropertiesByName = {};
         this.concreteMembers.forEach((member, memberI) => {
-            for (const memberTypeProperty of member.type.ownProperties.concat(member.type.ancestorObjectTypes.flatMap((ancestorObjectType) => ancestorObjectType.ownProperties))) {
+            for (const memberTypeProperty of member.type.properties.concat(member.type.ancestorObjectTypes.flatMap((ancestorObjectType) => ancestorObjectType.properties))) {
                 if (memberTypeProperty.kind !== "ShaclProperty") {
                     continue;
                 }

package/dist/generators/ts/TypeFactory.js

@@ -2,7 +2,7 @@ import TermMap from "@rdfjs/term-map";
 import TermSet from "@rdfjs/term-set";
 import { LiteralDecoder, literalDatatypeDefinitions } from "@rdfx/literal";
 import base62 from "@sindresorhus/base62";
-import { rdf, xsd } from "@tpluscode/rdf-ns-builders";
+import { rdf } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
 import reservedTsIdentifiers_ from "reserved-identifiers";
 import { invariant } from "ts-invariant";
@@ -112,16 +112,6 @@ export class TypeFactory {
                     visibility: "public",
                 });
             },
-            lazyIdentifierProperty: (namedObjectType) => new NamedObjectType.IdentifierProperty({
-                identifierMintingStrategy: astType.identifierMintingStrategy,
-                identifierPrefixPropertyName: `${syntheticNamePrefix}identifierPrefix`,
-                logger: this.logger,
-                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
@@ -142,28 +132,17 @@ export class TypeFactory {
                     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 (namedObjectTypeNeedsIdentifierPrefixProperty(astType)) {
-                    properties.splice(0, 0, new NamedObjectType.IdentifierPrefixProperty({
+                if (namedObjectType.declarationType === "interface" ||
+                    namedObjectType.parentObjectTypes.length === 0) {
+                    properties.splice(0, 0, new NamedObjectType.IdentifierProperty({
                         logger: this.logger,
-                        name: `${syntheticNamePrefix}identifierPrefix`,
+                        name: `${syntheticNamePrefix}identifier`,
                         namedObjectType,
-                        own: !astType.ancestorObjectTypes.some(namedObjectTypeNeedsIdentifierPrefixProperty),
-                        type: new StringType({
-                            comment: astType.comment,
-                            datatype: xsd.string,
-                            hasValues: [],
-                            in_: [],
-                            label: astType.label,
-                            logger: this.logger,
-                            languageIn: [],
-                            primitiveIn: [],
-                        }),
-                        visibility: "protected",
+                        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;
             },
             logger: this.logger,
@@ -321,7 +300,6 @@ export class TypeFactory {
             logger: this.logger,
             minCount: 0,
             mutable: astType.mutable,
-            identifierMintingStrategy: astType.identifierMintingStrategy,
             toRdfTypes: astType.toRdfTypes,
         });
     }
@@ -502,22 +480,6 @@ export class TypeFactory {
         });
     }
 }
-function namedObjectTypeNeedsIdentifierPrefixProperty(namedObjectType) {
-    return namedObjectType.identifierMintingStrategy
-        .map((identifierMintingStrategy) => {
-        switch (identifierMintingStrategy) {
-            case "blankNode":
-                return false;
-            case "sha256":
-            case "uuidv4":
-                return true;
-            default:
-                identifierMintingStrategy;
-                throw new RangeError(identifierMintingStrategy);
-        }
-    })
-        .orDefault(false);
-}
 function tsName(name, options) {
     if (name[0] === "$") {
         return name;

package/dist/generators/ts/_NamedObjectType/AbstractProperty.d.ts

@@ -12,13 +12,9 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "filterF
      */
     abstract readonly constructorParametersSignature: Maybe<Code>;
     /**
-     * Optional property declaration to include in a class or interface declaration of the object type.
+     * Property declaration to include in a class or interface declaration of the object type.
      */
-    abstract readonly declaration: Maybe<Code>;
-    /**
-     * Function declaration that takes two values of the property and compares them, returning an $EqualsResult.
-     */
-    abstract readonly equalsFunction: Maybe<Code>;
+    abstract readonly declaration: Code;
     /**
      * Optional property in the object type's filter.
      */
@@ -26,10 +22,6 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "filterF
         readonly name: string;
         readonly type: Code;
     }>;
-    /**
-     * Optional get accessor to include in a class declaration of the object type.
-     */
-    abstract readonly getAccessorDeclaration: Maybe<Code>;
     /**
      * GraphQL.js field definition.
      */
@@ -92,6 +84,14 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "filterF
         kind: Code;
         type: Code;
     };
+    /**
+     * Expression to access the value of this property on an object instance. May evaluate a thunk.
+     */
+    accessExpression({ variables }: {
+        variables: {
+            object: Code;
+        };
+    }): Code;
     /**
      * Statements to assign the parameter of described by constructorParametersSignature to a class or interface member.
      */

package/dist/generators/ts/_NamedObjectType/AbstractProperty.js

@@ -44,6 +44,12 @@ export class AbstractProperty {
             type: code `() => (${this.type.schema})`,
         };
     }
+    /**
+     * Expression to access the value of this property on an object instance. May evaluate a thunk.
+     */
+    accessExpression({ variables }) {
+        return code `${variables.object}.${this.name}`;
+    }
 }
 __decorate([
     Memoize()

package/dist/generators/ts/_NamedObjectType/DiscriminantProperty.d.ts

@@ -3,9 +3,7 @@ import { type Code } from "../ts-poet-wrapper.js";
 import { AbstractProperty } from "./AbstractProperty.js";
 export declare class DiscriminantProperty extends AbstractProperty<DiscriminantProperty.Type> {
     readonly constructorParametersSignature: Maybe<Code>;
-    readonly equalsFunction: Maybe<Code>;
     readonly filterProperty: AbstractProperty<DiscriminantProperty.Type>["filterProperty"];
-    readonly getAccessorDeclaration: Maybe<Code>;
     readonly graphqlField: AbstractProperty<DiscriminantProperty.Type>["graphqlField"];
     readonly kind = "DiscriminantProperty";
     readonly mutable = false;
@@ -13,7 +11,7 @@ export declare class DiscriminantProperty extends AbstractProperty<DiscriminantP
     constructor({ type, ...superParameters }: {
         type: DiscriminantProperty.Type;
     } & ConstructorParameters<typeof AbstractProperty>[0]);
-    get declaration(): Maybe<Code>;
+    get declaration(): Code;
     get jsonSchema(): AbstractProperty<DiscriminantProperty.Type>["jsonSchema"];
     get jsonSignature(): Maybe<Code>;
     private get abstract();

package/dist/generators/ts/_NamedObjectType/DiscriminantProperty.js

@@ -9,14 +9,11 @@ import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { imports } from "../imports.js";
 import { removeUndefined } from "../removeUndefined.js";
-import { snippets } from "../snippets.js";
 import { arrayOf, code, literalOf } from "../ts-poet-wrapper.js";
 import { AbstractProperty } from "./AbstractProperty.js";
 export class DiscriminantProperty extends AbstractProperty {
     constructorParametersSignature = Maybe.empty();
-    equalsFunction = Maybe.of(code `${snippets.strictEquals}`);
     filterProperty = Maybe.empty();
-    getAccessorDeclaration = Maybe.empty();
     graphqlField = Maybe.empty();
     kind = "DiscriminantProperty";
     mutable = false;
@@ -28,15 +25,18 @@ export class DiscriminantProperty extends AbstractProperty {
     get declaration() {
         switch (this.namedObjectType.declarationType) {
             case "class":
-                return Maybe.of(code `${this.abstract ? "abstract " : ""}${this.override ? "override " : ""}readonly ${this.name}: ${this.type.name}${!this.abstract ? code ` = ${this.initializer};` : ";"}`);
+                return code `${this.abstract ? "abstract " : ""}${this.override ? "override " : ""}readonly ${this.name}: ${this.type.name}${!this.abstract ? code ` = ${this.initializer};` : ";"}`;
             case "interface":
-                return Maybe.of(code `readonly ${this.name}: ${this.type.name};`);
+                return code `readonly ${this.name}: ${this.type.name};`;
             default:
                 this.namedObjectType.declarationType;
                 throw new Error("should never reach this point");
         }
     }
     get jsonSchema() {
+        if (this.override) {
+            return Maybe.empty();
+        }
         return Maybe.of({
             key: this.name,
             schema: this.type.values.length > 1
@@ -45,6 +45,9 @@ export class DiscriminantProperty extends AbstractProperty {
         });
     }
     get jsonSignature() {
+        if (this.override) {
+            return Maybe.empty();
+        }
         return Maybe.of(code `readonly ${this.name}: ${this.type.name}`);
     }
     get abstract() {
@@ -80,9 +83,15 @@ export class DiscriminantProperty extends AbstractProperty {
             : Maybe.empty();
     }
     hashStatements({ variables, }) {
+        if (this.override) {
+            return [];
+        }
         return [code `${variables.hasher}.update(${variables.value});`];
     }
     jsonUiSchemaElement({ variables, }) {
+        if (this.override) {
+            return Maybe.empty();
+        }
         const scope = code `\`\${${variables.scopePrefix}}/properties/${this.name}\``;
         return Maybe.of(code `{ rule: { condition: { schema: { const: ${this.initializer} }, scope: ${scope} }, effect: "HIDE" }, scope: ${scope}, type: "Control" }`);
     }
@@ -93,6 +102,9 @@ export class DiscriminantProperty extends AbstractProperty {
         return Maybe.empty();
     }
     toJsonObjectMemberExpression({ variables, }) {
+        if (this.override) {
+            return Maybe.empty();
+        }
         return Maybe.of(code `${this.name}: ${variables.value}`);
     }
     toRdfRdfResourceValuesStatements() {

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

@@ -1,41 +1,30 @@
 import { Maybe } from "purify-ts";
-import type { IdentifierMintingStrategy } from "../../../enums/IdentifierMintingStrategy.js";
 import type { BlankNodeType } from "../BlankNodeType.js";
 import type { IdentifierType } from "../IdentifierType.js";
 import type { IriType } from "../IriType.js";
 import { type Code } from "../ts-poet-wrapper.js";
 import { AbstractProperty } from "./AbstractProperty.js";
 export declare class IdentifierProperty extends AbstractProperty<BlankNodeType | IdentifierType | IriType> {
-    private readonly identifierMintingStrategy;
-    private readonly identifierPrefixPropertyName;
     private readonly typeAlias;
     readonly kind = "IdentifierProperty";
     readonly mutable = false;
     readonly recursive = false;
-    constructor({ identifierMintingStrategy, identifierPrefixPropertyName, typeAlias, ...superParameters }: {
-        identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
-        identifierPrefixPropertyName: string;
+    constructor({ typeAlias, ...superParameters }: {
         type: BlankNodeType | IdentifierType | IriType;
         typeAlias: Code;
     } & ConstructorParameters<typeof AbstractProperty>[0]);
     get constructorParametersSignature(): Maybe<Code>;
-    get declaration(): Maybe<Code>;
-    get equalsFunction(): Maybe<Code>;
+    get declaration(): Code;
     get filterProperty(): Maybe<{
         name: string;
         type: Code;
     }>;
-    get getAccessorDeclaration(): Maybe<Code>;
     get graphqlField(): AbstractProperty<IdentifierType>["graphqlField"];
-    get jsonSignature(): Maybe<Code>;
     get jsonSchema(): AbstractProperty<IdentifierType>["jsonSchema"];
-    private get abstract();
-    private get declarationModifiers();
-    private get declarationName();
-    private get override();
+    get jsonSignature(): Maybe<Code>;
+    accessExpression({ variables, }: Parameters<AbstractProperty<BlankNodeType | IdentifierType | IriType>["accessExpression"]>[0]): Code;
     constructorStatements({ variables, }: Parameters<AbstractProperty<IdentifierType>["constructorStatements"]>[0]): readonly Code[];
     fromJsonStatements({ variables, }: Parameters<AbstractProperty<IdentifierType>["fromJsonStatements"]>[0]): readonly Code[];
-    toStringExpression(parameters: Parameters<AbstractProperty<IdentifierType>["toStringExpression"]>[0]): Maybe<Code>;
     fromRdfResourceValuesExpression({ variables, }: Parameters<AbstractProperty<IdentifierType>["fromRdfResourceValuesExpression"]>[0]): Maybe<Code>;
     hashStatements({ variables, }: Parameters<AbstractProperty<IdentifierType>["hashStatements"]>[0]): readonly Code[];
     jsonUiSchemaElement({ variables, }: Parameters<AbstractProperty<IdentifierType>["jsonUiSchemaElement"]>[0]): Maybe<Code>;
@@ -46,5 +35,6 @@ export declare class IdentifierProperty extends AbstractProperty<BlankNodeType |
     }>;
     toJsonObjectMemberExpression({ variables, }: Parameters<AbstractProperty<IdentifierType>["toJsonObjectMemberExpression"]>[0]): Maybe<Code>;
     toRdfRdfResourceValuesStatements(): readonly Code[];
+    toStringExpression(parameters: Parameters<AbstractProperty<IdentifierType>["toStringExpression"]>[0]): Maybe<Code>;
 }
 //# sourceMappingURL=IdentifierProperty.d.ts.map