@shaclmate/compiler 2.0.22 → 2.0.24

package/dist/generators/ts/rdfjsTermExpression.d.ts

@@ -0,0 +1,3 @@
+import type { BlankNode, Literal, NamedNode, Variable } from "@rdfjs/types";
+export declare function rdfjsTermExpression(rdfjsTerm: Omit<BlankNode, "equals"> | Omit<Literal, "equals"> | Omit<NamedNode, "equals"> | Omit<Variable, "equals">): string;
+//# sourceMappingURL=rdfjsTermExpression.d.ts.map

package/dist/generators/ts/rdfjsTermExpression.js

@@ -0,0 +1,57 @@
+import { rdf, rdfs, xsd } from "@tpluscode/rdf-ns-builders";
+import { logger } from "../../logger.js";
+import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
+export function rdfjsTermExpression(rdfjsTerm) {
+    switch (rdfjsTerm.termType) {
+        case "BlankNode":
+            return `dataFactory.blankNode("${rdfjsTerm.value}")`;
+        case "Literal":
+            if (rdfjsTerm.datatype.equals(xsd.string)) {
+                if (rdfjsTerm.language.length === 0) {
+                    return `dataFactory.literal("${rdfjsTerm.value}")`;
+                }
+                return `dataFactory.literal("${rdfjsTerm.value}", "${rdfjsTerm.language}")`;
+            }
+            return `dataFactory.literal("${rdfjsTerm.value}", ${rdfjsTermExpression(rdfjsTerm.datatype)})`;
+        case "NamedNode": {
+            if (rdfjsTerm.value.startsWith(rdf[""].value)) {
+                const unqualifiedName = rdfjsTerm.value.substring(rdf[""].value.length);
+                switch (unqualifiedName) {
+                    case "first":
+                    case "nil":
+                    case "rest":
+                    case "subject":
+                    case "type":
+                        return `${syntheticNamePrefix}RdfVocabularies.rdf.${unqualifiedName}`;
+                    default:
+                        logger.warn("unrecognized rdf IRI: %s", rdfjsTerm.value);
+                }
+            }
+            else if (rdfjsTerm.value.startsWith(rdfs[""].value)) {
+                const unqualifiedName = rdfjsTerm.value.substring(rdfs[""].value.length);
+                switch (unqualifiedName) {
+                    case "subClassOf":
+                        return `${syntheticNamePrefix}RdfVocabularies.rdfs.${unqualifiedName}`;
+                    default:
+                        logger.warn("unrecognized rdfs IRI: %s", rdfjsTerm.value);
+                }
+            }
+            else if (rdfjsTerm.value.startsWith(xsd[""].value)) {
+                const unqualifiedName = rdfjsTerm.value.substring(xsd[""].value.length);
+                switch (unqualifiedName) {
+                    case "boolean":
+                    case "date":
+                    case "dateTime":
+                    case "integer":
+                        return `${syntheticNamePrefix}RdfVocabularies.xsd.${unqualifiedName}`;
+                    default:
+                        logger.warn("unrecognized xsd IRI: %s", rdfjsTerm.value);
+                }
+            }
+            return `dataFactory.namedNode("${rdfjsTerm.value}")`;
+        }
+        case "Variable":
+            return `dataFactory.variable!("${rdfjsTerm.value}")`;
+    }
+}
+//# sourceMappingURL=rdfjsTermExpression.js.map

package/dist/generators/ts/sparqlObjectSetClassDeclaration.d.ts

@@ -0,0 +1,8 @@
+import { type ClassDeclarationStructure, type ModuleDeclarationStructure } from "ts-morph";
+import type { ObjectType } from "./ObjectType.js";
+import type { ObjectUnionType } from "./ObjectUnionType.js";
+export declare function sparqlObjectSetClassDeclaration({ objectTypes, objectUnionTypes, }: {
+    objectTypes: readonly ObjectType[];
+    objectUnionTypes: readonly ObjectUnionType[];
+}): readonly (ClassDeclarationStructure | ModuleDeclarationStructure)[];
+//# sourceMappingURL=sparqlObjectSetClassDeclaration.d.ts.map

package/dist/generators/ts/sparqlObjectSetClassDeclaration.js

@@ -0,0 +1,415 @@
+import { Scope, StructureKind, } from "ts-morph";
+import { objectSetMethodSignatures } from "./objectSetMethodSignatures.js";
+import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
+import { unsupportedObjectSetMethodDeclarations } from "./unsupportedObjectSetMethodDeclarations.js";
+export function sparqlObjectSetClassDeclaration({ objectTypes, objectUnionTypes, }) {
+    const typeParameters = {
+        ObjectT: {
+            name: "ObjectT",
+        },
+        ObjectIdentifierT: {
+            constraint: "rdfjs.BlankNode | rdfjs.NamedNode",
+            name: "ObjectIdentifierT",
+        },
+    };
+    const sparqlWherePatternsFunctionType = `(parameters?: { subject?: sparqljs.Triple["subject"]; }) => readonly sparqljs.Pattern[]`;
+    const parameters = {
+        constructObjectType: {
+            name: "objectType",
+            type: `{\
+  ${syntheticNamePrefix}fromRdf: (resource: rdfjsResource.Resource, options: { objectSet: ${syntheticNamePrefix}ObjectSet }) => purify.Either<Error, ${typeParameters.ObjectT.name}>;
+  ${syntheticNamePrefix}sparqlConstructQueryString: (parameters?: { subject?: sparqljs.Triple["subject"]; } & Omit<sparqljs.ConstructQuery, "prefixes" | "queryType" | "type"> & sparqljs.GeneratorOptions) => string;
+  ${syntheticNamePrefix}sparqlWherePatterns: ${sparqlWherePatternsFunctionType};
+}`,
+        },
+        query: {
+            hasQuestionToken: true,
+            name: "query",
+            type: `${syntheticNamePrefix}SparqlObjectSet.Query<${typeParameters.ObjectIdentifierT.name}>`,
+        },
+        selectObjectTypeType: {
+            name: "objectType",
+            type: `{ ${syntheticNamePrefix}sparqlWherePatterns: ${sparqlWherePatternsFunctionType} }`,
+        },
+        where: {
+            hasQuestionToken: true,
+            name: "where",
+            type: `${syntheticNamePrefix}SparqlObjectSet.Where<${typeParameters.ObjectIdentifierT.name}>`,
+        },
+    };
+    return [
+        {
+            ctors: [
+                {
+                    parameters: [
+                        {
+                            name: "{ sparqlClient }",
+                            type: `{ sparqlClient: ${syntheticNamePrefix}SparqlObjectSet["${syntheticNamePrefix}sparqlClient"] }`,
+                        },
+                    ],
+                    statements: [
+                        `this.${syntheticNamePrefix}sparqlClient = sparqlClient;`,
+                    ],
+                },
+            ],
+            implements: [`${syntheticNamePrefix}ObjectSet`],
+            isExported: true,
+            kind: StructureKind.Class,
+            name: `${syntheticNamePrefix}SparqlObjectSet`,
+            // methods: [
+            methods: [...objectTypes, ...objectUnionTypes].flatMap((objectType) => {
+                if (!objectType.features.has("sparql")) {
+                    return unsupportedObjectSetMethodDeclarations({
+                        objectType,
+                    });
+                }
+                const methodSignatures = objectSetMethodSignatures({
+                    objectType,
+                    queryT: `${syntheticNamePrefix}SparqlObjectSet.Query`,
+                });
+                const runtimeObjectType = objectType.staticModuleName;
+                return [
+                    {
+                        ...methodSignatures.object,
+                        kind: StructureKind.Method,
+                        isAsync: true,
+                        statements: [
+                            `return (await this.${methodSignatures.objects.name}({ where: { identifiers: [identifier], type: "identifiers" } })).map(objects => objects[0]);`,
+                        ],
+                    },
+                    {
+                        ...methodSignatures.objectIdentifiers,
+                        kind: StructureKind.Method,
+                        isAsync: true,
+                        statements: [
+                            `return this.${syntheticNamePrefix}objectIdentifiers<${objectType.identifierTypeAlias}>(${runtimeObjectType}, query);`,
+                        ],
+                    },
+                    {
+                        ...methodSignatures.objects,
+                        kind: StructureKind.Method,
+                        isAsync: true,
+                        statements: [
+                            `return this.${syntheticNamePrefix}objects<${objectType.name}, ${objectType.identifierTypeAlias}>(${runtimeObjectType}, query);`,
+                        ],
+                    },
+                    {
+                        ...methodSignatures.objectsCount,
+                        isAsync: true,
+                        kind: StructureKind.Method,
+                        statements: [
+                            `return this.${syntheticNamePrefix}objectsCount<${objectType.identifierTypeAlias}>(${runtimeObjectType}, query);`,
+                        ],
+                    },
+                ];
+            }).concat({
+                kind: StructureKind.Method,
+                name: `${syntheticNamePrefix}mapBindingsToCount`,
+                parameters: [
+                    {
+                        name: "bindings",
+                        type: "readonly Record<string, rdfjs.BlankNode | rdfjs.Literal | rdfjs.NamedNode>[]",
+                    },
+                    {
+                        name: "variable",
+                        type: "string",
+                    },
+                ],
+                returnType: "purify.Either<Error, number>",
+                scope: Scope.Protected,
+                statements: [
+                    `\
+if (bindings.length === 0) {
+  return purify.Left(new Error("empty result rows"));
+}
+if (bindings.length > 1) {
+  return purify.Left(new Error("more than one result row"));
+}
+const count = bindings[0][variable];
+if (typeof count === "undefined") {
+  return purify.Left(new Error("no 'count' variable in result row"));
+}
+if (count.termType !== "Literal") {
+  return purify.Left(new Error("'count' variable is not a Literal"));
+}
+const parsedCount = Number.parseInt(count.value);
+if (Number.isNaN(parsedCount)) {
+  return purify.Left(new Error("'count' variable is NaN"));
+}
+return purify.Either.of(parsedCount);`,
+                ],
+            }, {
+                kind: StructureKind.Method,
+                name: `${syntheticNamePrefix}mapBindingsToIdentifiers`,
+                parameters: [
+                    {
+                        name: "bindings",
+                        type: "readonly Record<string, rdfjs.BlankNode | rdfjs.Literal | rdfjs.NamedNode>[]",
+                    },
+                    {
+                        name: "variable",
+                        type: "string",
+                    },
+                ],
+                returnType: "readonly rdfjs.NamedNode[]",
+                scope: Scope.Protected,
+                statements: [
+                    `\
+const identifiers: rdfjs.NamedNode[] = [];
+for (const bindings_ of bindings) {
+  const identifier = bindings_[variable];
+  if (
+    typeof identifier !== "undefined" &&
+    identifier.termType === "NamedNode"
+  ) {
+    identifiers.push(identifier);
+  }
+}
+return identifiers;`,
+                ],
+            }, {
+                kind: StructureKind.Method,
+                isAsync: true,
+                name: `${syntheticNamePrefix}objectIdentifiers`,
+                parameters: [parameters.selectObjectTypeType, parameters.query],
+                returnType: `Promise<purify.Either<Error, readonly ${typeParameters.ObjectIdentifierT.name}[]>>`,
+                scope: Scope.Protected,
+                statements: [
+                    `\
+const limit = query?.limit ?? Number.MAX_SAFE_INTEGER;
+if (limit <= 0) {
+  return purify.Either.of([]);
+}
+
+let offset = query?.offset ?? 0;
+if (offset < 0) {
+  offset = 0;
+}
+
+const wherePatterns = this.${syntheticNamePrefix}wherePatterns(objectType, query?.where).filter(pattern => pattern.type !== "optional");
+if (wherePatterns.length === 0) {
+  return purify.Left(new Error("no required SPARQL WHERE patterns for identifiers"));
+}
+
+const selectQueryString = \
+  this.${syntheticNamePrefix}sparqlGenerator.stringify({
+    distinct: true,
+    limit: limit < Number.MAX_SAFE_INTEGER ? limit : undefined,
+    offset,
+    order: query?.order ? query.order(this.${syntheticNamePrefix}objectVariable).concat() : [{ expression: this.${syntheticNamePrefix}objectVariable }],
+    prefixes: {},
+    queryType: "SELECT",
+    type: "query",
+    variables: [this.${syntheticNamePrefix}objectVariable],
+    where: wherePatterns
+  });
+  
+return purify.EitherAsync(async () =>
+  this.${syntheticNamePrefix}mapBindingsToIdentifiers(
+    await this.${syntheticNamePrefix}sparqlClient.queryBindings(selectQueryString),
+    this.${syntheticNamePrefix}objectVariable.value,
+  ) as readonly ${typeParameters.ObjectIdentifierT.name}[],
+);`,
+                ],
+                typeParameters: [typeParameters.ObjectIdentifierT],
+            }, {
+                isAsync: true,
+                kind: StructureKind.Method,
+                name: `${syntheticNamePrefix}objects`,
+                parameters: [parameters.constructObjectType, parameters.query],
+                returnType: `Promise<purify.Either<Error, readonly ${typeParameters.ObjectT.name}[]>>`,
+                statements: [
+                    `\
+const identifiersEither = await this.${syntheticNamePrefix}objectIdentifiers<${typeParameters.ObjectIdentifierT.name}>(objectType, query);
+if (identifiersEither.isLeft()) {
+  return identifiersEither;
+}
+const identifiers = identifiersEither.unsafeCoerce();
+if (identifiers.length === 0) {
+  return purify.Either.of([]);
+}
+
+const constructQueryString = objectType.${syntheticNamePrefix}sparqlConstructQueryString({
+  subject: this.${syntheticNamePrefix}objectVariable,
+  where: [{
+    type: "values" as const,
+    values: identifiers.map((identifier) => {
+      const valuePatternRow: sparqljs.ValuePatternRow = {};
+      valuePatternRow["?object"] = identifier as rdfjs.NamedNode;
+      return valuePatternRow;
+    }),
+  }]
+});
+
+let quads: readonly rdfjs.Quad[];
+try {
+  quads = await this.${syntheticNamePrefix}sparqlClient.queryQuads(constructQueryString);
+} catch (e) {
+  return purify.Left(e as Error);
+}
+
+const dataset = datasetFactory.dataset(quads.concat());
+const objects: ${typeParameters.ObjectT.name}[] = [];
+for (const identifier of identifiers) {
+  const objectEither = objectType.${syntheticNamePrefix}fromRdf(
+    new rdfjsResource.Resource<rdfjs.NamedNode>({ dataset, identifier: identifier as rdfjs.NamedNode }),
+    { objectSet: this }
+  );
+  if (objectEither.isLeft()) {
+    return objectEither;
+  }
+  objects.push(objectEither.unsafeCoerce());
+}
+return purify.Either.of(objects);`,
+                ],
+                typeParameters: [
+                    typeParameters.ObjectT,
+                    typeParameters.ObjectIdentifierT,
+                ],
+            }, {
+                kind: StructureKind.Method,
+                isAsync: true,
+                name: `${syntheticNamePrefix}objectsCount`,
+                parameters: [parameters.selectObjectTypeType, parameters.query],
+                returnType: "Promise<purify.Either<Error, number>>",
+                scope: Scope.Protected,
+                statements: [
+                    `\
+const wherePatterns = this.${syntheticNamePrefix}wherePatterns(objectType, query?.where).filter(pattern => pattern.type !== "optional");
+if (wherePatterns.length === 0) {
+  return purify.Left(new Error("no required SPARQL WHERE patterns for count"));
+}
+
+const selectQueryString = \
+  this.${syntheticNamePrefix}sparqlGenerator.stringify({
+    prefixes: {},
+    queryType: "SELECT",
+    type: "query",
+    variables: [
+      {
+        expression: {
+          aggregation: "COUNT",
+          distinct: true,
+          expression: this.${syntheticNamePrefix}objectVariable,
+          type: "aggregate",
+        },
+        variable: this.${syntheticNamePrefix}countVariable,
+      },
+    ],
+    where: wherePatterns
+  });
+
+return purify.EitherAsync(async ({ liftEither }) =>
+  liftEither(
+    this.${syntheticNamePrefix}mapBindingsToCount(
+      await this.${syntheticNamePrefix}sparqlClient.queryBindings(selectQueryString),
+      this.${syntheticNamePrefix}countVariable.value,
+    ),
+  ),
+);`,
+                ],
+                typeParameters: [typeParameters.ObjectIdentifierT],
+            }, {
+                kind: StructureKind.Method,
+                name: `${syntheticNamePrefix}wherePatterns`,
+                parameters: [parameters.selectObjectTypeType, parameters.where],
+                returnType: "sparqljs.Pattern[]",
+                scope: Scope.Protected,
+                statements: [
+                    `\
+const patterns: sparqljs.Pattern[] = [];
+
+// Patterns should be most to least specific.
+
+if (where) {
+  // Assign a separate variable so the compiler catches any missing cases
+  let wherePatterns: readonly sparqljs.Pattern[];
+  switch (where.type) {
+    case "identifiers": {
+      const valuePatternRowKey = \`?\${this.${syntheticNamePrefix}objectVariable.value}\`;
+      wherePatterns = [{
+        type: "values" as const,
+        values: where.identifiers.map((identifier) => {
+          const valuePatternRow: sparqljs.ValuePatternRow = {};
+          valuePatternRow[valuePatternRowKey] = identifier as rdfjs.NamedNode;
+          return valuePatternRow;
+        }),
+      }];
+      break;
+    }
+    case "sparql-patterns": {
+      wherePatterns = where.sparqlPatterns(this.${syntheticNamePrefix}objectVariable);
+      break;
+    }
+    case "triple-objects": {
+      wherePatterns = [{
+        triples: [{
+          subject: where.subject,
+          predicate: where.predicate,
+          object: this.${syntheticNamePrefix}objectVariable
+        }],
+        type: "bgp"
+      }];
+      break;
+    }
+  }
+  patterns.push(...wherePatterns);
+}
+
+patterns.push(...objectType.${syntheticNamePrefix}sparqlWherePatterns({ subject: this.${syntheticNamePrefix}objectVariable }));
+
+return patterns;`,
+                ],
+                typeParameters: [typeParameters.ObjectIdentifierT],
+            }),
+            properties: [
+                {
+                    initializer: `dataFactory.variable!("count");`,
+                    isReadonly: true,
+                    name: `${syntheticNamePrefix}countVariable`,
+                    scope: Scope.Protected,
+                },
+                {
+                    initializer: `dataFactory.variable!("object");`,
+                    isReadonly: true,
+                    name: `${syntheticNamePrefix}objectVariable`,
+                    scope: Scope.Protected,
+                },
+                {
+                    isReadonly: true,
+                    name: `${syntheticNamePrefix}sparqlClient`,
+                    scope: Scope.Protected,
+                    type: "{ queryBindings: (query: string) => Promise<readonly Record<string, rdfjs.BlankNode | rdfjs.Literal | rdfjs.NamedNode>[]>; queryQuads: (query: string) => Promise<readonly rdfjs.Quad[]>; }",
+                },
+                {
+                    initializer: "new sparqljs.Generator()",
+                    isReadonly: true,
+                    name: `${syntheticNamePrefix}sparqlGenerator`,
+                    scope: Scope.Protected,
+                },
+            ],
+        },
+        {
+            isExported: true,
+            kind: StructureKind.Module,
+            name: `${syntheticNamePrefix}SparqlObjectSet`,
+            statements: [
+                {
+                    isExported: true,
+                    kind: StructureKind.TypeAlias,
+                    name: "Query",
+                    type: `Omit<${syntheticNamePrefix}ObjectSet.Query<${typeParameters.ObjectIdentifierT.name}>, "where"> & { readonly order?: (objectVariable: rdfjs.Variable) => readonly sparqljs.Ordering[]; readonly where?: Where<${typeParameters.ObjectIdentifierT.name}> }`,
+                    typeParameters: [typeParameters.ObjectIdentifierT],
+                },
+                {
+                    kind: StructureKind.TypeAlias,
+                    isExported: true,
+                    name: "Where",
+                    type: `${syntheticNamePrefix}ObjectSet.Where<${typeParameters.ObjectIdentifierT.name}> | { readonly sparqlPatterns: (objectVariable: rdfjs.Variable) => readonly sparqljs.Pattern[]; readonly type: "sparql-patterns" }`,
+                    typeParameters: [typeParameters.ObjectIdentifierT],
+                },
+            ],
+        },
+    ];
+}
+//# sourceMappingURL=sparqlObjectSetClassDeclaration.js.map

package/dist/generators/ts/syntheticNamePrefix.d.ts

@@ -0,0 +1,2 @@
+export declare const syntheticNamePrefix = "$";
+//# sourceMappingURL=syntheticNamePrefix.d.ts.map

package/dist/generators/ts/syntheticNamePrefix.js

@@ -0,0 +1,2 @@
+export const syntheticNamePrefix = "$";
+//# sourceMappingURL=syntheticNamePrefix.js.map

package/dist/generators/ts/tsName.js

@@ -1,19 +1,33 @@
 import { Resource } from "rdfjs-resource";
 import { stringToValidTsIdentifier } from "./stringToValidTsIdentifier.js";
+import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
+function* tsNameAlternatives(astName) {
+    yield astName.shaclmateName.extract();
+    yield astName.shName.extract()?.replace(" ", "_");
+    yield astName.label.extract()?.replace(" ", "_");
+    yield astName.propertyPath
+        .chain((propertyPath) => propertyPath.uniqueLocalPart())
+        .extract();
+    yield astName.propertyPath
+        .chain((propertyPath) => propertyPath.curie.map((curie) => `${curie.prefix}_${curie.reference}`))
+        .extract();
+    if (astName.identifier.termType === "NamedNode") {
+        yield astName.identifier.uniqueLocalPart().extract();
+        yield astName.identifier.curie
+            .map((curie) => `${curie.prefix}_${curie.reference}`)
+            .extract();
+    }
+    yield astName.propertyPath
+        .map((propertyPath) => Resource.Identifier.toString(propertyPath))
+        .extract();
+    yield Resource.Identifier.toString(astName.identifier);
+}
 export function tsName(astName) {
-    for (const tsNameAlternative of [
-        astName.shaclmateName.extract(),
-        astName.shName.extract()?.replace(" ", "_"),
-        astName.label.extract()?.replace(" ", "_"),
-        astName.curie.map((curie) => curie.replace(":", "_")).extract(),
-        astName.propertyPath
-            .chain((propertyPath) => propertyPath.curie.map((curie) => curie.replace(":", "_")))
-            .extract(),
-        astName.propertyPath
-            .map((propertyPath) => Resource.Identifier.toString(propertyPath.identifier))
-            .extract(),
-        Resource.Identifier.toString(astName.identifier),
-    ]) {
+    const syntheticName = astName.syntheticName.extract();
+    if (syntheticName) {
+        return `${syntheticNamePrefix}${syntheticName}`;
+    }
+    for (const tsNameAlternative of tsNameAlternatives(astName)) {
         if (tsNameAlternative) {
             return stringToValidTsIdentifier(tsNameAlternative);
         }

package/dist/generators/ts/unsupportedObjectSetMethodDeclarations.d.ts

@@ -0,0 +1,10 @@
+import { type MethodDeclarationStructure } from "ts-morph";
+import type { ObjectType } from "./ObjectType.js";
+export declare function unsupportedObjectSetMethodDeclarations({ objectType, }: {
+    objectType: {
+        readonly identifierTypeAlias: string;
+        readonly objectSetMethodNames: ObjectType.ObjectSetMethodNames;
+        readonly name: string;
+    };
+}): readonly MethodDeclarationStructure[];
+//# sourceMappingURL=unsupportedObjectSetMethodDeclarations.d.ts.map

package/dist/generators/ts/unsupportedObjectSetMethodDeclarations.js

@@ -0,0 +1,19 @@
+import { StructureKind } from "ts-morph";
+import { objectSetMethodSignatures } from "./objectSetMethodSignatures.js";
+export function unsupportedObjectSetMethodDeclarations({ objectType, }) {
+    return Object.entries(objectSetMethodSignatures({ objectType })).map(([methodName, methodSignature]) => ({
+        ...methodSignature,
+        kind: StructureKind.Method,
+        parameters: methodSignature.parameters
+            ? methodSignature.parameters.map((parameter) => ({
+                ...parameter,
+                name: `_${parameter.name}`,
+            }))
+            : methodSignature.parameters,
+        isAsync: true,
+        statements: methodName === "objects"
+            ? [`return [purify.Left(new Error("${methodName}: not supported"))];`]
+            : [`return purify.Left(new Error("${methodName}: not supported"));`],
+    }));
+}
+//# sourceMappingURL=unsupportedObjectSetMethodDeclarations.js.map

package/dist/input/NodeShape.d.ts

@@ -1,18 +1,18 @@
 import type { NamedNode } from "@rdfjs/types";
-import { NodeShape as ShaclCoreNodeShape } from "@shaclmate/shacl-ast";
+import { type IdentifierNodeKind, NodeShape as ShaclCoreNodeShape } from "@shaclmate/shacl-ast";
 import { Maybe } from "purify-ts";
+import type * as generated from "./generated.js";
 import type { IdentifierMintingStrategy, TsFeature, TsObjectDeclarationType } from "../enums/index.js";
 import type { Shape } from "./Shape.js";
-import type * as generated from "./generated.js";
 import type { Ontology, PropertyGroup, PropertyShape, ShapesGraph } from "./index.js";
 export declare class NodeShape extends ShaclCoreNodeShape<any, Ontology, PropertyGroup, PropertyShape, Shape> {
-    readonly isClass: boolean;
-    readonly isList: boolean;
     private readonly ancestorClassIris;
     private readonly childClassIris;
     private readonly descendantClassIris;
     private readonly generatedShaclmateNodeShape;
     private readonly parentClassIris;
+    readonly isClass: boolean;
+    readonly isList: boolean;
     constructor({ ancestorClassIris, childClassIris, descendantClassIris, generatedShaclmateNodeShape, isClass, isList, parentClassIris, shapesGraph, }: {
         ancestorClassIris: readonly NamedNode[];
         generatedShaclmateNodeShape: generated.ShaclmateNodeShape;
@@ -32,16 +32,14 @@ export declare class NodeShape extends ShaclCoreNodeShape<any, Ontology, Propert
     get fromRdfType(): Maybe<NamedNode>;
     get identifierMintingStrategy(): Maybe<IdentifierMintingStrategy>;
     get mutable(): Maybe<boolean>;
-    get nodeKinds(): Set<"BlankNode" | "NamedNode">;
+    get nodeKinds(): Set<IdentifierNodeKind>;
     get parentNodeShapes(): readonly NodeShape[];
+    get rdfType(): Maybe<NamedNode>;
     get shaclmateName(): Maybe<string>;
     get toRdfTypes(): readonly NamedNode[];
     get tsFeatures(): Maybe<Set<TsFeature>>;
     get tsImports(): readonly string[];
     get tsObjectDeclarationType(): Maybe<TsObjectDeclarationType>;
-    get tsObjectIdentifierPrefixPropertyName(): Maybe<string>;
-    get tsObjectIdentifierPropertyName(): Maybe<string>;
-    get tsObjectTypeDiscriminatorPropertyName(): Maybe<string>;
     private get _mintingStrategy();
 }
 //# sourceMappingURL=NodeShape.d.ts.map