@shaclmate/compiler 2.0.20 → 2.0.23

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstCompositeType.js

@@ -3,56 +3,17 @@ import { Either, Left, Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import * as input from "../input/index.js";
 import { logger } from "../logger.js";
+import { flattenAstObjectCompositeTypeMemberTypes } from "./flattenAstObjectCompositeTypeMemberTypes.js";
 /**
  * Try to convert a property shape to a composite type (intersection or union) using some heuristics.
  */
 export function transformPropertyShapeToAstCompositeType(shape, inherited) {
     const defaultValue = (shape instanceof input.PropertyShape ? shape.defaultValue : Maybe.empty()).alt(inherited !== null ? inherited.defaultValue : Maybe.empty());
-    const hasValues = shape.constraints.hasValues;
-    const extern = shape.extern.alt(inherited !== null ? inherited.extern : Maybe.empty());
     let memberTypeEithers;
     let compositeTypeKind;
-    const transformNodeShapeToAstCompositeMemberType = (nodeShape) => {
-        const astTypeEither = this.transformNodeShapeToAstType(nodeShape);
-        if (astTypeEither.isLeft()) {
-            return astTypeEither;
-        }
-        const astType = astTypeEither.unsafeCoerce();
-        if (extern.orDefault(false)) {
-            // Use the identifier type instead
-            let nodeKinds;
-            switch (astType.kind) {
-                case "ListType":
-                    nodeKinds = new Set();
-                    nodeKinds.add(astType.identifierNodeKind);
-                    break;
-                case "ObjectType":
-                    nodeKinds = astType.identifierKinds;
-                    break;
-                case "ObjectIntersectionType":
-                case "ObjectUnionType":
-                    nodeKinds = new Set();
-                    for (const memberType of astType.memberTypes) {
-                        for (const nodeKind of memberType.identifierKinds) {
-                            nodeKinds.add(nodeKind);
-                        }
-                    }
-            }
-            return Either.of({
-                defaultValue: defaultValue.filter((term) => term.termType === "NamedNode"),
-                hasValues: [],
-                in_: [],
-                kind: "IdentifierType",
-                nodeKinds,
-            });
-        }
-        // Not extern, use the type
-        return Either.of(astType);
-    };
     if (shape.constraints.and.length > 0) {
         memberTypeEithers = shape.constraints.and.map((memberShape) => this.transformPropertyShapeToAstType(memberShape, {
             defaultValue,
-            extern: extern,
         }));
         compositeTypeKind = "IntersectionType";
     }
@@ -69,7 +30,7 @@ export function transformPropertyShapeToAstCompositeType(shape, inherited) {
             if (classNodeShape === null) {
                 return Left(new Error(`class ${classIri.value} did not resolve to a node shape`));
             }
-            return transformNodeShapeToAstCompositeMemberType(classNodeShape);
+            return this.transformNodeShapeToAstType(classNodeShape);
         });
         compositeTypeKind = "IntersectionType";
         if (Either.rights(memberTypeEithers).length === 0) {
@@ -79,13 +40,12 @@ export function transformPropertyShapeToAstCompositeType(shape, inherited) {
         }
     }
     else if (shape.constraints.nodes.length > 0) {
-        memberTypeEithers = shape.constraints.nodes.map((nodeShape) => transformNodeShapeToAstCompositeMemberType(nodeShape));
+        memberTypeEithers = shape.constraints.nodes.map((nodeShape) => this.transformNodeShapeToAstType(nodeShape));
         compositeTypeKind = "IntersectionType";
     }
     else if (shape.constraints.xone.length > 0) {
         memberTypeEithers = shape.constraints.xone.map((memberShape) => this.transformPropertyShapeToAstType(memberShape, {
             defaultValue,
-            extern: extern,
         }));
         compositeTypeKind = "UnionType";
     }
@@ -93,108 +53,141 @@ export function transformPropertyShapeToAstCompositeType(shape, inherited) {
         return Left(new Error(`unable to transform ${shape} into an AST type`));
     }
     invariant(memberTypeEithers.length > 0);
-    const memberTypes = Either.rights(memberTypeEithers);
-    if (memberTypes.length !== memberTypeEithers.length) {
-        logger.warn("shape %s composition did not map all member types successfully: %s", shape, Either.lefts(memberTypeEithers)
-            .map((left) => left.message)
-            .join("; "));
-        return memberTypeEithers[0];
+    let memberObjectTypes = [];
+    let memberTypes = [];
+    for (const memberTypeEither of memberTypeEithers) {
+        if (memberTypeEither.isLeft()) {
+            return memberTypeEither;
+        }
+        const memberType = memberTypeEither.unsafeCoerce();
+        memberTypes.push(memberType);
+        switch (memberType.kind) {
+            case "ObjectType":
+            case "ObjectIntersectionType":
+            case "ObjectUnionType":
+                memberObjectTypes.push(memberType);
+                break;
+        }
     }
-    invariant(memberTypes.length > 0);
     if (memberTypes.length === 1) {
         return Either.of(memberTypes[0]);
     }
+    if (memberTypes.length === memberObjectTypes.length) {
+        // If all the member types are ast.ObjectType, flatten them.
+        const flattenedMemberTypesEither = flattenAstObjectCompositeTypeMemberTypes({
+            objectCompositeTypeKind: compositeTypeKind === "IntersectionType"
+                ? "ObjectIntersectionType"
+                : "ObjectUnionType",
+            memberTypes: memberObjectTypes,
+            shape,
+        });
+        if (flattenedMemberTypesEither.isLeft()) {
+            return flattenedMemberTypesEither;
+        }
+        const { memberTypes: flattenedMemberTypes } = flattenedMemberTypesEither.unsafeCoerce();
+        memberTypes = memberObjectTypes = flattenedMemberTypes.concat();
+    }
+    return widenAstCompositeTypeToSingleType({
+        defaultValue,
+        memberTypes,
+        shape,
+    }).altLazy(() => 
+    // True composite type
+    Either.of({
+        kind: compositeTypeKind,
+        memberTypes,
+    }));
+}
+function widenAstCompositeTypeToSingleType({ defaultValue, memberTypes, shape, }) {
+    if (shape.constraints.hasValues.length > 0) {
+        return Left(new Error(`shape ${shape} hasValues, not attempting to widen composite type into a single type`));
+    }
+    if (shape instanceof input.PropertyShape && !shape.widen.orDefault(true)) {
+        return Left(new Error(`shape ${shape} has widening disabled`));
+    }
     // Get the type underlying a set or option
     const memberItemTypes = memberTypes.map((memberType) => {
         switch (memberType.kind) {
-            case "SetType":
-                return memberType.itemType;
             case "OptionType":
                 return memberType.itemType;
+            case "SetType":
+                return memberType.itemType;
             default:
                 return memberType;
         }
     });
-    if (hasValues.length === 0) {
-        // Can't handle hasValues when coalescing types
-        const canCoalesce = (memberItemType) => {
-            if (memberItemType.in_.length > 0) {
-                return false;
-            }
-            switch (memberItemType.kind) {
-                case "LiteralType": {
-                    if (memberItemType.maxExclusive.isJust()) {
-                        return false;
-                    }
-                    if (memberItemType.maxInclusive.isJust()) {
-                        return false;
-                    }
-                    if (memberItemType.minExclusive.isJust()) {
-                        return false;
-                    }
-                    if (memberItemType.minInclusive.isJust()) {
-                        return false;
-                    }
+    const canWiden = (memberItemType) => {
+        if (memberItemType.in_.length > 0) {
+            return false;
+        }
+        switch (memberItemType.kind) {
+            case "LiteralType": {
+                if (memberItemType.maxExclusive.isJust()) {
+                    return false;
+                }
+                if (memberItemType.maxInclusive.isJust()) {
+                    return false;
+                }
+                if (memberItemType.minExclusive.isJust()) {
+                    return false;
+                }
+                if (memberItemType.minInclusive.isJust()) {
+                    return false;
                 }
             }
-            return true;
-        };
-        if (memberItemTypes.every((memberItemType) => memberItemType.kind === "IdentifierType" &&
-            canCoalesce(memberItemType))) {
-            // Special case: all member types are identifiers without further constraints
-            return Either.of({
-                defaultValue: defaultValue.filter((term) => term.termType === "NamedNode"),
-                hasValues: [],
-                in_: [],
-                kind: "IdentifierType",
-                nodeKinds: new Set(memberItemTypes
-                    .filter((memberItemType) => memberItemType.kind === "IdentifierType")
-                    .flatMap((memberItemType) => [
-                    ...memberItemType.nodeKinds,
-                ])),
-            });
-        }
-        if (memberItemTypes.every((memberItemType) => memberItemType.kind === "LiteralType" && canCoalesce(memberItemType))) {
-            // Special case: all the member types are Literals without further constraints,
-            // like dash:StringOrLangString
-            // Don't try to coalesce range constraints.
-            return Either.of({
-                datatype: Maybe.empty(),
-                defaultValue: defaultValue.filter((term) => term.termType === "Literal"),
-                hasValues: [],
-                in_: [],
-                kind: "LiteralType",
-                languageIn: [],
-                maxExclusive: Maybe.empty(),
-                maxInclusive: Maybe.empty(),
-                minExclusive: Maybe.empty(),
-                minInclusive: Maybe.empty(),
-                nodeKinds: new Set(["Literal"]),
-            });
-        }
-        if (memberItemTypes.every((memberItemType) => (memberItemType.kind === "IdentifierType" ||
-            memberItemType.kind === "LiteralType" ||
-            memberItemType.kind === "TermType") &&
-            canCoalesce(memberItemType))) {
-            // Special case: all member types are terms without further constraints
-            const nodeKinds = new Set(memberItemTypes.flatMap((memberItemType) => [
-                ...memberItemType
-                    .nodeKinds,
-            ]));
-            invariant(nodeKinds.has("Literal") &&
-                (nodeKinds.has("BlankNode") || nodeKinds.has("NamedNode"))); // The identifier-identifier and literal-literal cases should have been caught above
-            return Either.of({
-                defaultValue,
-                hasValues: [],
-                in_: [],
-                kind: "TermType",
-                nodeKinds,
-            });
         }
+        return true;
+    };
+    if (memberItemTypes.every((memberItemType) => memberItemType.kind === "IdentifierType" && canWiden(memberItemType))) {
+        // Special case: all member types are identifiers without further constraints
+        return Either.of({
+            defaultValue: defaultValue.filter((term) => term.termType === "NamedNode"),
+            hasValues: [],
+            in_: [],
+            kind: "IdentifierType",
+            nodeKinds: new Set(memberItemTypes
+                .filter((memberItemType) => memberItemType.kind === "IdentifierType")
+                .flatMap((memberItemType) => [
+                ...memberItemType.nodeKinds,
+            ])),
+        });
     }
-    return Either.of({
-        kind: compositeTypeKind,
-        memberTypes: memberTypes,
-    });
+    if (memberItemTypes.every((memberItemType) => memberItemType.kind === "LiteralType" && canWiden(memberItemType))) {
+        // Special case: all the member types are Literals without further constraints,
+        // like dash:StringOrLangString
+        // Don't try to widen range constraints.
+        return Either.of({
+            datatype: Maybe.empty(),
+            defaultValue: defaultValue.filter((term) => term.termType === "Literal"),
+            hasValues: [],
+            in_: [],
+            kind: "LiteralType",
+            languageIn: [],
+            maxExclusive: Maybe.empty(),
+            maxInclusive: Maybe.empty(),
+            minExclusive: Maybe.empty(),
+            minInclusive: Maybe.empty(),
+            nodeKinds: new Set(["Literal"]),
+        });
+    }
+    if (memberItemTypes.every((memberItemType) => (memberItemType.kind === "IdentifierType" ||
+        memberItemType.kind === "LiteralType" ||
+        memberItemType.kind === "TermType") &&
+        canWiden(memberItemType))) {
+        // Special case: all member types are terms without further constraints
+        const nodeKinds = new Set(memberItemTypes.flatMap((memberItemType) => [
+            ...memberItemType.nodeKinds,
+        ]));
+        invariant(nodeKinds.has("Literal") &&
+            (nodeKinds.has("BlankNode") || nodeKinds.has("NamedNode"))); // The identifier-identifier and literal-literal cases should have been caught above
+        return Either.of({
+            defaultValue,
+            hasValues: [],
+            in_: [],
+            kind: "TermType",
+            nodeKinds,
+        });
+    }
+    return Left(new Error(`shape ${shape} member types could not be widened into a single type`));
 }
 //# sourceMappingURL=transformPropertyShapeToAstCompositeType.js.map

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstIdentifierType.d.ts

@@ -1,4 +1,4 @@
-import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
+import type { Literal, NamedNode } from "@rdfjs/types";
 import { Either, Maybe } from "purify-ts";
 import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
 import type * as ast from "../ast/index.js";
@@ -7,6 +7,6 @@ import * as input from "../input/index.js";
  * Try to convert a property shape to an AST IdentifierType using some heuristics.
  */
 export declare function transformPropertyShapeToAstIdentifierType(this: ShapesGraphToAstTransformer, shape: input.Shape, inherited: {
-    defaultValue: Maybe<BlankNode | Literal | NamedNode>;
+    defaultValue: Maybe<Literal | NamedNode>;
 } | null): Either<Error, ast.IdentifierType>;
 //# sourceMappingURL=transformPropertyShapeToAstIdentifierType.d.ts.map

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstLiteralType.d.ts

@@ -1,4 +1,4 @@
-import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
+import type { Literal, NamedNode } from "@rdfjs/types";
 import { Either, Maybe } from "purify-ts";
 import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
 import type * as ast from "../ast/index.js";
@@ -7,6 +7,6 @@ import * as input from "../input/index.js";
  * Try to convert a property shape to an AST LiteralType using some heuristics.
  */
 export declare function transformPropertyShapeToAstLiteralType(this: ShapesGraphToAstTransformer, shape: input.Shape, inherited: {
-    defaultValue: Maybe<BlankNode | Literal | NamedNode>;
+    defaultValue: Maybe<Literal | NamedNode>;
 } | null): Either<Error, ast.LiteralType>;
 //# sourceMappingURL=transformPropertyShapeToAstLiteralType.d.ts.map

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstObjectTypeProperty.js

@@ -1,5 +1,61 @@
-import { Either, Left } from "purify-ts";
+import N3 from "n3";
+import { Either, Left, Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
 import { pickLiteral } from "./pickLiteral.js";
+function identifierNodeKinds(type) {
+    switch (type.kind) {
+        case "ObjectType":
+            return type.identifierNodeKinds;
+        case "ObjectUnionType":
+            return new Set(type.memberTypes.flatMap((memberType) => [
+                ...memberType.identifierNodeKinds,
+            ]));
+    }
+}
+function synthesizeStubAstObjectType({ identifierNodeKinds, tsFeatures, }) {
+    let syntheticName;
+    switch (identifierNodeKinds.size) {
+        case 1:
+            invariant(identifierNodeKinds.has("NamedNode"));
+            syntheticName = "NamedDefaultStub";
+            break;
+        case 2:
+            syntheticName = "DefaultStub";
+            break;
+        default:
+            throw new Error("should never happen");
+    }
+    return {
+        abstract: false,
+        ancestorObjectTypes: [],
+        childObjectTypes: [],
+        comment: Maybe.empty(),
+        descendantObjectTypes: [],
+        export: true,
+        extern: false,
+        fromRdfType: Maybe.empty(),
+        identifierIn: [],
+        identifierNodeKinds,
+        identifierMintingStrategy: Maybe.empty(),
+        kind: "ObjectType",
+        label: Maybe.empty(),
+        name: {
+            identifier: N3.DataFactory.blankNode(),
+            label: Maybe.empty(),
+            propertyPath: Maybe.empty(),
+            shName: Maybe.empty(),
+            shaclmateName: Maybe.empty(),
+            syntheticName: Maybe.of(syntheticName),
+        },
+        parentObjectTypes: [],
+        properties: [],
+        synthetic: true,
+        toRdfTypes: [],
+        tsFeatures,
+        tsImports: [],
+        tsObjectDeclarationType: "class",
+    };
+}
 export function transformPropertyShapeToAstObjectTypeProperty(propertyShape) {
     {
         const property = this.astObjectTypePropertiesByIdentifier.get(propertyShape.identifier);
@@ -7,9 +63,74 @@ export function transformPropertyShapeToAstObjectTypeProperty(propertyShape) {
             return Either.of(property);
         }
     }
-    const type = this.transformPropertyShapeToAstType(propertyShape, null);
-    if (type.isLeft()) {
-        return type;
+    const typeEither = this.transformPropertyShapeToAstType(propertyShape, null);
+    if (typeEither.isLeft()) {
+        return typeEither;
+    }
+    const type = typeEither.unsafeCoerce();
+    let stubType = Maybe.empty();
+    let propertyShapeStubType;
+    if (propertyShape.stub.isJust()) {
+        const propertyShapeStubTypeEither = this.transformNodeShapeToAstType(propertyShape.stub.unsafeCoerce()).chain((propertyShapeStubType) => {
+            switch (propertyShapeStubType.kind) {
+                case "ListType":
+                case "ObjectIntersectionType":
+                    return Left(new Error(`${propertyShape} stub cannot refer to a ${propertyShapeStubType.kind}`));
+                case "ObjectType":
+                case "ObjectUnionType":
+                    return Either.of(propertyShapeStubType);
+            }
+        });
+        if (propertyShapeStubTypeEither.isLeft()) {
+            return propertyShapeStubTypeEither;
+        }
+        propertyShapeStubType = propertyShapeStubTypeEither.unsafeCoerce();
+    }
+    if (propertyShapeStubType || propertyShape.lazy.orDefault(false)) {
+        switch (type.kind) {
+            case "ObjectType":
+            case "ObjectUnionType": {
+                stubType = Maybe.of(propertyShapeStubType ??
+                    synthesizeStubAstObjectType({
+                        identifierNodeKinds: identifierNodeKinds(type),
+                        tsFeatures: type.tsFeatures,
+                    }));
+                break;
+            }
+            case "OptionType":
+            case "SetType": {
+                switch (type.itemType.kind) {
+                    case "ObjectType":
+                    case "ObjectUnionType": {
+                        const stubItemType = propertyShapeStubType ??
+                            synthesizeStubAstObjectType({
+                                identifierNodeKinds: identifierNodeKinds(type.itemType),
+                                tsFeatures: type.itemType.tsFeatures,
+                            });
+                        if (type.kind === "OptionType") {
+                            stubType = Maybe.of({
+                                kind: "OptionType",
+                                itemType: stubItemType,
+                            });
+                        }
+                        else {
+                            stubType = Maybe.of({
+                                kind: "SetType",
+                                itemType: stubItemType,
+                                minCount: 0,
+                                mutable: Maybe.empty(),
+                            });
+                        }
+                        break;
+                    }
+                    default:
+                        return Left(new Error(`${propertyShape} marked lazy but has ${type.kind} of ${type.itemType.kind}`));
+                }
+                break;
+            }
+            default:
+                return Left(new Error(`${propertyShape} marked lazy but has ${type.kind}`));
+        }
     }
     const path = propertyShape.path;
     if (path.kind !== "PredicatePath") {
@@ -23,7 +144,8 @@ export function transformPropertyShapeToAstObjectTypeProperty(propertyShape) {
         name: this.shapeAstName(propertyShape),
         order: propertyShape.order.orDefault(0),
         path,
-        type: type.extract(),
+        stubType,
+        type,
         visibility: propertyShape.visibility,
     };
     this.astObjectTypePropertiesByIdentifier.set(propertyShape.identifier, property);

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstTermType.d.ts

@@ -1,4 +1,4 @@
-import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
+import type { Literal, NamedNode } from "@rdfjs/types";
 import { Either, Maybe } from "purify-ts";
 import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
 import type * as ast from "../ast/index.js";
@@ -7,8 +7,8 @@ import * as input from "../input/index.js";
  * Try to convert a property shape to an AST TermType using some heuristics.
  */
 export declare function transformPropertyShapeToAstTermType(this: ShapesGraphToAstTransformer, shape: input.Shape, inherited: {
-    defaultValue: Maybe<BlankNode | Literal | NamedNode>;
-} | null): Either<Error, Omit<ast.TermType<BlankNode | Literal | NamedNode>, "kind"> & {
+    defaultValue: Maybe<Literal | NamedNode>;
+} | null): Either<Error, Omit<ast.TermType, "kind"> & {
     readonly kind: "TermType";
 }>;
 //# sourceMappingURL=transformPropertyShapeToAstTermType.d.ts.map

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstType.d.ts

@@ -1,4 +1,4 @@
-import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
+import type { Literal, NamedNode } from "@rdfjs/types";
 import type { Either, Maybe } from "purify-ts";
 import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
 import type * as ast from "../ast/index.js";
@@ -10,7 +10,6 @@ import * as input from "../input/index.js";
  * a shape has one type.
  */
 export declare function transformPropertyShapeToAstType(this: ShapesGraphToAstTransformer, shape: input.Shape, inherited: {
-    defaultValue: Maybe<BlankNode | Literal | NamedNode>;
-    extern: Maybe<boolean>;
+    defaultValue: Maybe<Literal | NamedNode>;
 } | null): Either<Error, ast.Type>;
 //# sourceMappingURL=transformPropertyShapeToAstType.d.ts.map

package/dist/ast/Ast.d.ts

@@ -5,6 +5,5 @@ export interface Ast {
     readonly objectIntersectionTypes: readonly ObjectIntersectionType[];
     readonly objectTypes: readonly ObjectType[];
     readonly objectUnionTypes: readonly ObjectUnionType[];
-    readonly tsDataFactoryVariable: string;
 }
 //# sourceMappingURL=Ast.d.ts.map

package/dist/ast/Curie.d.ts

@@ -0,0 +1,14 @@
+/**
+ * A Compact URI (https://www.w3.org/TR/curie)
+ */
+export declare class Curie {
+    readonly prefix: string;
+    readonly reference: string;
+    constructor({ prefix, reference, }: {
+        prefix: string;
+        reference: string;
+    });
+    static parse(curie: string): Curie;
+    toString(): string;
+}
+//# sourceMappingURL=Curie.d.ts.map

package/dist/ast/Curie.js

@@ -0,0 +1,21 @@
+import { invariant } from "ts-invariant";
+/**
+ * A Compact URI (https://www.w3.org/TR/curie)
+ */
+export class Curie {
+    prefix;
+    reference;
+    constructor({ prefix, reference, }) {
+        this.prefix = prefix;
+        this.reference = reference;
+    }
+    static parse(curie) {
+        const split = curie.split(":", 2);
+        invariant(split.length === 2);
+        return new Curie({ prefix: split[0], reference: split[1] });
+    }
+    toString() {
+        return `${this.prefix}:${this.reference}`;
+    }
+}
+//# sourceMappingURL=Curie.js.map

package/dist/ast/IdentifierType.d.ts

@@ -1,10 +1,11 @@
 import type { BlankNode, NamedNode } from "@rdfjs/types";
+import type { IdentifierNodeKind } from "@shaclmate/shacl-ast";
 import type { TermType } from "./TermType.js";
 /**
  * A type corresponding to sh:nodeKind of a blank node or IRI, and not corresponding to a node shape.
  */
-export interface IdentifierType extends TermType<BlankNode | NamedNode> {
+export interface IdentifierType extends TermType<NamedNode, BlankNode | NamedNode> {
     readonly kind: "IdentifierType";
-    readonly nodeKinds: Set<"BlankNode" | "NamedNode">;
+    readonly nodeKinds: Set<IdentifierNodeKind>;
 }
 //# sourceMappingURL=IdentifierType.d.ts.map

package/dist/ast/ListType.d.ts

@@ -1,4 +1,5 @@
 import type { NamedNode } from "@rdfjs/types";
+import type { IdentifierNodeKind } from "@shaclmate/shacl-ast";
 import type { Maybe } from "purify-ts";
 import type { IdentifierMintingStrategy } from "../enums/IdentifierMintingStrategy.js";
 import type { Name } from "./Name.js";
@@ -18,7 +19,7 @@ export interface ListType {
     /**
      * Type of identifier (blank or named node) to use for lists and sub-lists.
      */
-    readonly identifierNodeKind: "BlankNode" | "NamedNode";
+    readonly identifierNodeKind: IdentifierNodeKind;
     /**
      * List item type.
      *

package/dist/ast/LiteralType.d.ts

@@ -1,7 +1,7 @@
 import type { Literal, NamedNode } from "@rdfjs/types";
 import type { Maybe } from "purify-ts";
 import type { TermType } from "./TermType.js";
-export interface LiteralType extends TermType<Literal> {
+export interface LiteralType extends TermType<Literal, Literal> {
     readonly datatype: Maybe<NamedNode>;
     readonly kind: "LiteralType";
     readonly languageIn: readonly string[];

package/dist/ast/Name.d.ts

@@ -1,14 +1,49 @@
 import type { BlankNode, NamedNode } from "@rdfjs/types";
 import type { Maybe } from "purify-ts";
+import type { Curie } from "./Curie.js";
 export interface Name {
-    readonly curie: Maybe<string>;
-    readonly identifier: BlankNode | NamedNode;
+    readonly identifier: BlankNode | (NamedNode & {
+        /**
+         * Compact URI (CURIE).
+         */
+        readonly curie: Maybe<Curie>;
+        /**
+         * Unique unqualified/local identifier, derived from the CURIE.
+         *
+         * Returns Just if the local identifier is unique across all CURIEs, otherwise Nothing.
+         */
+        readonly uniqueLocalPart: () => Maybe<string>;
+    });
+    /**
+     * rdfs:label.
+     */
     readonly label: Maybe<string>;
-    readonly propertyPath: Maybe<{
-        curie: Maybe<string>;
-        identifier: NamedNode;
+    /**
+     * sh:path for property shapes.
+     */
+    readonly propertyPath: Maybe<NamedNode & {
+        /**
+         * Compact URI (CURIE).
+         */
+        readonly curie: Maybe<Curie>;
+        /**
+         * Unique unqualified/local identifier, derived from the CURIE.
+         *
+         * Returns Just if the local identifier is unique across all CURIEs, otherwise Nothing.
+         */
+        readonly uniqueLocalPart: () => Maybe<string>;
     }>;
+    /**
+     * sh:name.
+     */
     readonly shName: Maybe<string>;
+    /**
+     * shaclmate:name.
+     */
     readonly shaclmateName: Maybe<string>;
+    /**
+     * Synthesized in code.
+     */
+    readonly syntheticName: Maybe<string>;
 }
 //# sourceMappingURL=Name.d.ts.map