@shaclmate/compiler 2.0.22 → 2.0.23

package/dist/ShapesGraphToAstTransformer.d.ts

@@ -7,6 +7,7 @@ import type * as ast from "./ast/index.js";
 import type * as input from "./input/index.js";
 export declare class ShapesGraphToAstTransformer {
     protected readonly astObjectTypePropertiesByIdentifier: TermMap<rdfjs.BlankNode | rdfjs.NamedNode, ast.ObjectType.Property>;
+    protected readonly iriLocalParts: Record<string, Record<string, number>>;
     protected readonly iriPrefixMap: PrefixMap;
     protected readonly nodeShapeAstTypesByIdentifier: TermMap<rdfjs.BlankNode | rdfjs.NamedNode, _ShapesGraphToAstTransformer.NodeShapeAstType>;
     protected shapeAstName: typeof _ShapesGraphToAstTransformer.shapeAstName;

package/dist/ShapesGraphToAstTransformer.js

@@ -1,10 +1,11 @@
 import TermMap from "@rdfjs/term-map";
 import { dash } from "@tpluscode/rdf-ns-builders";
-import { Either, Maybe } from "purify-ts";
+import { Either } from "purify-ts";
 import * as _ShapesGraphToAstTransformer from "./_ShapesGraphToAstTransformer/index.js";
 export class ShapesGraphToAstTransformer {
     // Members are protected so they're accessible to the bound functions
     astObjectTypePropertiesByIdentifier = new TermMap();
+    iriLocalParts = {};
     iriPrefixMap;
     nodeShapeAstTypesByIdentifier = new TermMap();
     shapeAstName = _ShapesGraphToAstTransformer.shapeAstName;
@@ -21,17 +22,60 @@ export class ShapesGraphToAstTransformer {
         this.shapesGraph = shapesGraph;
     }
     transform() {
-        return Either.sequence(this.shapesGraph.nodeShapes
-            .filter((nodeShape) => nodeShape.identifier.termType === "NamedNode" &&
-            !nodeShape.identifier.value.startsWith(dash[""].value))
-            .map((nodeShape) => this.transformNodeShapeToAstType(nodeShape))).map((nodeShapeAstTypes) => ({
-            objectIntersectionTypes: nodeShapeAstTypes.filter((nodeShapeAstType) => nodeShapeAstType.kind === "ObjectIntersectionType"),
-            objectTypes: nodeShapeAstTypes.filter((nodeShapeAstType) => nodeShapeAstType.kind === "ObjectType"),
-            objectUnionTypes: nodeShapeAstTypes.filter((nodeShapeAstType) => nodeShapeAstType.kind === "ObjectUnionType"),
-            tsDataFactoryVariable: (this.shapesGraph.ontologies.length === 1
-                ? this.shapesGraph.ontologies[0].tsDataFactoryVariable
-                : Maybe.empty()).orDefault("dataFactory"),
-        }));
+        const nodeShapeAstObjectIntersectionTypes = [];
+        const nodeShapeAstObjectTypes = [];
+        const syntheticAstObjectTypesByName = {};
+        const nodeShapeAstObjectUnionTypes = [];
+        for (const nodeShape of this.shapesGraph.nodeShapes) {
+            if (nodeShape.identifier.termType !== "NamedNode") {
+                continue;
+            }
+            if (nodeShape.identifier.value.startsWith(dash[""].value)) {
+                continue;
+            }
+            const nodeShapeAstTypeEither = this.transformNodeShapeToAstType(nodeShape);
+            if (nodeShapeAstTypeEither.isLeft()) {
+                continue;
+            }
+            const nodeShapeAstType = nodeShapeAstTypeEither.unsafeCoerce();
+            switch (nodeShapeAstType.kind) {
+                case "ListType":
+                    break; // Ignore
+                case "ObjectIntersectionType":
+                    nodeShapeAstObjectIntersectionTypes.push(nodeShapeAstType);
+                    break;
+                case "ObjectType": {
+                    nodeShapeAstObjectTypes.push(nodeShapeAstType);
+                    for (const property of nodeShapeAstType.properties) {
+                        property.stubType
+                            .map((stubType) => stubType.kind === "ObjectType" ||
+                            stubType.kind === "ObjectUnionType"
+                            ? stubType
+                            : stubType.itemType)
+                            .filter((stubItemType) => stubItemType.kind === "ObjectType")
+                            .filter((stubItemType) => stubItemType.synthetic)
+                            .ifJust((stubItemType) => {
+                            const stubItemTypeName = stubItemType.name.syntheticName.unsafeCoerce();
+                            if (!syntheticAstObjectTypesByName[stubItemTypeName]) {
+                                syntheticAstObjectTypesByName[stubItemTypeName] =
+                                    stubItemType;
+                            }
+                        });
+                    }
+                    break;
+                }
+                case "ObjectUnionType":
+                    nodeShapeAstObjectUnionTypes.push(nodeShapeAstType);
+                    break;
+                default:
+                    nodeShapeAstType;
+            }
+        }
+        return Either.of({
+            objectIntersectionTypes: nodeShapeAstObjectIntersectionTypes,
+            objectTypes: nodeShapeAstObjectTypes.concat(Object.values(syntheticAstObjectTypesByName)),
+            objectUnionTypes: nodeShapeAstObjectUnionTypes,
+        });
     }
 }
 //# sourceMappingURL=ShapesGraphToAstTransformer.js.map

package/dist/_ShapesGraphToAstTransformer/flattenAstObjectCompositeTypeMemberTypes.d.ts

@@ -0,0 +1,13 @@
+import type { TsFeature } from "enums/TsFeature.js";
+import { Either } from "purify-ts";
+import type * as ast from "../ast/index.js";
+import type * as input from "../input/index.js";
+export declare function flattenAstObjectCompositeTypeMemberTypes({ objectCompositeTypeKind, memberTypes, shape, }: {
+    objectCompositeTypeKind: "ObjectIntersectionType" | "ObjectUnionType";
+    memberTypes: readonly (ast.ObjectType | ast.ObjectIntersectionType | ast.ObjectUnionType)[];
+    shape: input.Shape;
+}): Either<Error, {
+    memberTypes: readonly ast.ObjectType[];
+    tsFeatures: Set<TsFeature>;
+}>;
+//# sourceMappingURL=flattenAstObjectCompositeTypeMemberTypes.d.ts.map

package/dist/_ShapesGraphToAstTransformer/flattenAstObjectCompositeTypeMemberTypes.js

@@ -0,0 +1,51 @@
+import TermSet from "@rdfjs/term-set";
+import { Either, Left } from "purify-ts";
+import { Resource } from "rdfjs-resource";
+export function flattenAstObjectCompositeTypeMemberTypes({ objectCompositeTypeKind, memberTypes, shape, }) {
+    const flattenedMemberTypes = [];
+    for (const memberType of memberTypes) {
+        switch (memberType.kind) {
+            case "ObjectType":
+                flattenedMemberTypes.push(memberType);
+                break;
+            case "ObjectIntersectionType":
+            case "ObjectUnionType":
+                if (memberType.kind === objectCompositeTypeKind) {
+                    flattenedMemberTypes.push(...memberType.memberTypes);
+                    break;
+                }
+                return Left(new Error(`${objectCompositeTypeKind} with a nested ${memberType.kind}`));
+        }
+    }
+    // Members of the composite type must have the same tsFeatures.
+    // They must also have distinct RDF types or no RDF types at all.
+    const nonExternMemberTypes = flattenedMemberTypes.filter((memberType) => !memberType.extern);
+    const fromRdfTypes = new TermSet();
+    const tsFeatures = new Set();
+    for (let memberTypeI = 0; memberTypeI < nonExternMemberTypes.length; memberTypeI++) {
+        const memberType = nonExternMemberTypes[memberTypeI];
+        if (memberTypeI === 0) {
+            for (const tsFeature of memberType.tsFeatures) {
+                tsFeatures.add(tsFeature);
+            }
+        }
+        memberType.fromRdfType.ifJust((fromRdfType) => fromRdfTypes.add(fromRdfType));
+        if (memberType.tsFeatures.size !== tsFeatures.size) {
+            return Left(new Error(`${shape} has a member ObjectType (${Resource.Identifier.toString(memberType.name.identifier)}) with different tsFeatures than the other member ObjectType's`));
+        }
+        for (const tsFeature of memberType.tsFeatures) {
+            if (!tsFeatures.has(tsFeature)) {
+                return Left(new Error(`${shape} has a member ObjectType (${Resource.Identifier.toString(memberType.name.identifier)}) with different tsFeatures than the other member ObjectType's`));
+            }
+        }
+    }
+    if (fromRdfTypes.size > 0 &&
+        fromRdfTypes.size !== nonExternMemberTypes.length) {
+        return Left(new Error(`one or more ${shape} members ([${nonExternMemberTypes.map((memberType) => Resource.Identifier.toString(memberType.name.identifier)).join(", ")}]) lack distinguishing fromRdfType's ({${[...fromRdfTypes].map((fromRdfType) => Resource.Identifier.toString(fromRdfType)).join(", ")}})`));
+    }
+    return Either.of({
+        memberTypes: flattenedMemberTypes,
+        tsFeatures,
+    });
+}
+//# sourceMappingURL=flattenAstObjectCompositeTypeMemberTypes.js.map

package/dist/_ShapesGraphToAstTransformer/shapeAstName.js

@@ -1,28 +1,69 @@
 import { Maybe } from "purify-ts";
+import { Curie } from "../ast/Curie.js";
 import * as input from "../input/index.js";
+import { logger } from "../logger.js";
 import { pickLiteral } from "./pickLiteral.js";
 export function shapeAstName(shape) {
-    let propertyPath = Maybe.empty();
-    let shName = Maybe.empty();
+    const namedIdentifier = (namedNode) => {
+        const curie = Maybe.fromNullable(this.iriPrefixMap.shrink(namedNode)?.value).map(Curie.parse);
+        curie.ifJust((curie) => {
+            if (typeof this.iriLocalParts[curie.reference] === "undefined") {
+                this.iriLocalParts[curie.reference] = {};
+            }
+            if (typeof this.iriLocalParts[curie.reference][curie.prefix] === "undefined") {
+                this.iriLocalParts[curie.reference][curie.prefix] = 1;
+            }
+            else {
+                this.iriLocalParts[curie.reference][curie.prefix] += 1;
+            }
+        });
+        return {
+            equals: (other) => {
+                return namedNode.equals(other);
+            },
+            curie,
+            termType: "NamedNode",
+            uniqueLocalPart: () => curie
+                .filter((curie) => {
+                const curieReferenceInPrefixes = this.iriLocalParts[curie.reference];
+                if (Object.entries(curieReferenceInPrefixes).length === 1) {
+                    return true;
+                }
+                logger.debug(`duplicate local part ${curie.reference} in ${JSON.stringify(curieReferenceInPrefixes)}`);
+                return false;
+            })
+                .map((curie) => curie.reference),
+            value: namedNode.value,
+        };
+    };
+    let propertyPath;
+    let shName;
     if (shape instanceof input.PropertyShape) {
         if (shape.path.kind === "PredicatePath") {
-            const pathIri = shape.path.iri;
-            propertyPath = Maybe.of({
-                curie: Maybe.fromNullable(this.iriPrefixMap.shrink(pathIri)?.value),
-                identifier: pathIri,
-            });
+            propertyPath = Maybe.of(namedIdentifier(shape.path.iri));
+            // logger.debug(
+            //   `shape ${shape} property path: ${JSON.stringify(propertyPath.unsafeCoerce())}`,
+            // );
+        }
+        else {
+            propertyPath = Maybe.empty();
+            logger.warn(`property shape ${shape} has ${shape.path.kind} path`);
         }
         shName = pickLiteral(shape.names).map((literal) => literal.value);
     }
+    else {
+        propertyPath = Maybe.empty();
+        shName = Maybe.empty();
+    }
     return {
-        curie: shape.identifier.termType === "NamedNode"
-            ? Maybe.fromNullable(this.iriPrefixMap.shrink(shape.identifier)?.value)
-            : Maybe.empty(),
-        identifier: shape.identifier,
+        identifier: shape.identifier.termType === "NamedNode"
+            ? namedIdentifier(shape.identifier)
+            : shape.identifier,
         label: pickLiteral(shape.labels).map((literal) => literal.value),
         propertyPath,
-        shName: shName,
+        shName,
         shaclmateName: shape.shaclmateName,
+        syntheticName: Maybe.empty(),
     };
 }
 //# sourceMappingURL=shapeAstName.js.map

package/dist/_ShapesGraphToAstTransformer/transformNodeShapeToAstType.d.ts

@@ -1,6 +1,11 @@
 import { Either } from "purify-ts";
 import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
+import type * as ast from "../ast/index.js";
 import * as input from "../input/index.js";
 import type { NodeShapeAstType } from "./NodeShapeAstType.js";
+export declare function transformNodeShapeToAstObjectCompositeType(this: ShapesGraphToAstTransformer, { export_, nodeShape, }: {
+    export_: boolean;
+    nodeShape: input.NodeShape;
+}): Either<Error, ast.ObjectIntersectionType | ast.ObjectUnionType>;
 export declare function transformNodeShapeToAstType(this: ShapesGraphToAstTransformer, nodeShape: input.NodeShape): Either<Error, NodeShapeAstType>;
 //# sourceMappingURL=transformNodeShapeToAstType.d.ts.map

package/dist/_ShapesGraphToAstTransformer/transformNodeShapeToAstType.js

@@ -1,15 +1,16 @@
 import { rdf } from "@tpluscode/rdf-ns-builders";
 import { Either, Left, Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
-import { TsFeature } from "../enums/index.js";
 import * as input from "../input/index.js";
+import { tsFeaturesDefault } from "../input/tsFeatures.js";
 import { logger } from "../logger.js";
+import { flattenAstObjectCompositeTypeMemberTypes } from "./flattenAstObjectCompositeTypeMemberTypes.js";
 import { pickLiteral } from "./pickLiteral.js";
 /**
  * Is an ast.ObjectType actually the shape of an RDF list?
  * If so, return the type of its rdf:first.
  */
-function transformNodeShapeToListType(nodeShape) {
+function transformNodeShapeToAstListType(nodeShape) {
     invariant(nodeShape.isList);
     // Put a placeholder in the cache to deal with cyclic references
     const listType = {
@@ -68,6 +69,73 @@ function transformNodeShapeToListType(nodeShape) {
     listType.itemType = firstProperty.type;
     return Either.of(listType);
 }
+export function transformNodeShapeToAstObjectCompositeType({ export_, nodeShape, }) {
+    let compositeTypeShapes;
+    let compositeTypeKind;
+    if (nodeShape.constraints.and.length > 0) {
+        compositeTypeShapes = nodeShape.constraints.and;
+        compositeTypeKind = "ObjectIntersectionType";
+    }
+    else if (nodeShape.constraints.xone.length > 0) {
+        compositeTypeShapes = nodeShape.constraints.xone;
+        compositeTypeKind = "ObjectUnionType";
+    }
+    else {
+        throw new Error("should never be reached");
+    }
+    const compositeTypeNodeShapes = [];
+    for (const compositeTypeShape of compositeTypeShapes) {
+        if (!(compositeTypeShape instanceof input.NodeShape)) {
+            return Left(new Error(`${nodeShape} has non-NodeShape in its logical constraint`));
+        }
+        compositeTypeNodeShapes.push(compositeTypeShape);
+    }
+    if (compositeTypeNodeShapes.length === 0) {
+        return Left(new Error(`${nodeShape} has no NodeShapes in its logical constraint`));
+    }
+    // Put a placeholder in the cache to deal with cyclic references
+    const compositeType = {
+        comment: pickLiteral(nodeShape.comments).map((literal) => literal.value),
+        export: export_,
+        kind: compositeTypeKind,
+        label: pickLiteral(nodeShape.labels).map((literal) => literal.value),
+        memberTypes: [],
+        name: this.shapeAstName(nodeShape),
+        tsFeatures: new Set(),
+    };
+    this.nodeShapeAstTypesByIdentifier.set(nodeShape.identifier, compositeType);
+    const memberTypes = [];
+    for (const memberNodeShape of compositeTypeNodeShapes) {
+        const memberTypeEither = this.transformNodeShapeToAstType(memberNodeShape);
+        if (memberTypeEither.isLeft()) {
+            return memberTypeEither;
+        }
+        const memberType = memberTypeEither.unsafeCoerce();
+        switch (memberType.kind) {
+            case "ObjectType":
+            case "ObjectIntersectionType":
+            case "ObjectUnionType":
+                memberTypes.push(memberType);
+                break;
+            default:
+                return Left(new Error(`${nodeShape} has one or more non-ObjectType node shapes in its logical constraint`));
+        }
+    }
+    return flattenAstObjectCompositeTypeMemberTypes({
+        objectCompositeTypeKind: compositeTypeKind,
+        memberTypes,
+        shape: nodeShape,
+    }).map(({ memberTypes, tsFeatures }) => {
+        // Add to the placeholder composite type and return it.
+        for (const memberType of memberTypes) {
+            compositeType.memberTypes.push(memberType);
+        }
+        for (const tsFeature of tsFeatures) {
+            compositeType.tsFeatures.add(tsFeature);
+        }
+        return compositeType;
+    });
+}
 export function transformNodeShapeToAstType(nodeShape) {
     {
         const type = this.nodeShapeAstTypesByIdentifier.get(nodeShape.identifier);
@@ -76,55 +144,27 @@ export function transformNodeShapeToAstType(nodeShape) {
         }
     }
     if (nodeShape.isList) {
-        return transformNodeShapeToListType.bind(this)(nodeShape);
+        return transformNodeShapeToAstListType.bind(this)(nodeShape);
     }
     const export_ = nodeShape.export.orDefault(true);
     if (nodeShape.constraints.and.length > 0 ||
         nodeShape.constraints.xone.length > 0) {
-        let compositeTypeShapes;
-        let compositeTypeKind;
-        if (nodeShape.constraints.and.length > 0) {
-            compositeTypeShapes = nodeShape.constraints.and;
-            compositeTypeKind = "ObjectIntersectionType";
-        }
-        else {
-            compositeTypeShapes = nodeShape.constraints.xone;
-            compositeTypeKind = "ObjectUnionType";
-        }
-        const compositeTypeNodeShapes = compositeTypeShapes.filter((shape) => shape instanceof input.NodeShape);
-        if (compositeTypeNodeShapes.length === 0) {
-            return Left(new Error(`${nodeShape} has no node shapes in its logical constraint`));
-        }
-        // Put a placeholder in the cache to deal with cyclic references
-        const compositeType = {
-            comment: pickLiteral(nodeShape.comments).map((literal) => literal.value),
-            export: export_,
-            kind: compositeTypeKind,
-            label: pickLiteral(nodeShape.labels).map((literal) => literal.value),
-            memberTypes: [],
-            name: this.shapeAstName(nodeShape),
-            tsFeatures: nodeShape.tsFeatures.orDefault(new Set(TsFeature.MEMBERS)),
-        };
-        this.nodeShapeAstTypesByIdentifier.set(nodeShape.identifier, compositeType);
-        for (const memberNodeShape of compositeTypeNodeShapes) {
-            const memberAstTypeEither = this.transformNodeShapeToAstType(memberNodeShape);
-            if (memberAstTypeEither.isLeft()) {
-                return memberAstTypeEither;
-            }
-            const memberAstType = memberAstTypeEither.unsafeCoerce();
-            switch (memberAstType.kind) {
-                case "ObjectType":
-                    compositeType.memberTypes.push(memberAstType);
-                    break;
-                case "ObjectUnionType":
-                    compositeType.memberTypes.push(...memberAstType.memberTypes);
-                    break;
-                default:
-                    return Left(new Error(`${nodeShape} has one or more non-ObjectType node shapes in its logical constraint`));
-            }
-        }
-        return Either.of(compositeType);
+        return transformNodeShapeToAstObjectCompositeType.bind(this)({
+            export_,
+            nodeShape,
+        });
+    }
+    const fromRdfType = nodeShape.fromRdfType.alt(nodeShape.rdfType);
+    const toRdfTypes = nodeShape.toRdfTypes.concat();
+    if (toRdfTypes.length === 0) {
+        toRdfTypes.push(...nodeShape.rdfType.toList());
     }
+    // Ensure toRdfTypes has fromRdfType
+    fromRdfType.ifJust((fromRdfType) => {
+        if (!toRdfTypes.some((toRdfType) => toRdfType.equals(fromRdfType))) {
+            toRdfTypes.push(fromRdfType);
+        }
+    });
     const identifierIn = nodeShape.constraints.in_.filter((term) => term.termType === "NamedNode");
     // Put a placeholder in the cache to deal with cyclic references
     // If this node shape's properties (directly or indirectly) refer to the node shape itself,
@@ -137,24 +177,22 @@ export function transformNodeShapeToAstType(nodeShape) {
         descendantObjectTypes: [],
         export: export_,
         extern: nodeShape.extern.orDefault(false),
-        fromRdfType: nodeShape.fromRdfType,
+        fromRdfType,
         label: pickLiteral(nodeShape.labels).map((literal) => literal.value),
         kind: "ObjectType",
         identifierIn,
         identifierMintingStrategy: identifierIn.length === 0
             ? nodeShape.identifierMintingStrategy
             : Maybe.empty(),
-        identifierKinds: identifierIn.length === 0 ? nodeShape.nodeKinds : new Set(["NamedNode"]),
+        identifierNodeKinds: identifierIn.length === 0 ? nodeShape.nodeKinds : new Set(["NamedNode"]),
         name: this.shapeAstName(nodeShape),
         properties: [], // This is mutable, we'll populate it below.
         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"),
+        synthetic: false,
+        toRdfTypes,
+        tsFeatures: nodeShape.tsFeatures.orDefault(new Set(tsFeaturesDefault)),
         tsImports: nodeShape.tsImports,
         tsObjectDeclarationType: nodeShape.tsObjectDeclarationType.orDefault("class"),
-        tsTypeDiscriminatorPropertyName: nodeShape.tsObjectTypeDiscriminatorPropertyName.orDefault("type"),
     };
     this.nodeShapeAstTypesByIdentifier.set(nodeShape.identifier, objectType);
     // Populate ancestor and descendant object types
@@ -169,6 +207,40 @@ export function transformNodeShapeToAstType(nodeShape) {
     objectType.descendantObjectTypes.push(...relatedObjectTypes(nodeShape.descendantNodeShapes));
     objectType.parentObjectTypes.push(...relatedObjectTypes(nodeShape.parentNodeShapes));
     // Populate properties
+    // Check whether a type refers to this ObjectType
+    const isPropertyRecursive = (astType) => {
+        switch (astType.kind) {
+            case "IdentifierType":
+            case "LiteralType":
+            case "PlaceholderType":
+            case "TermType":
+                return false;
+            case "ObjectType":
+                if (astType.name === objectType.name) {
+                    return true;
+                }
+                for (const property of astType.properties) {
+                    if (isPropertyRecursive(property.type)) {
+                        return true;
+                    }
+                }
+                return false;
+            case "IntersectionType":
+            case "ObjectIntersectionType":
+            case "ObjectUnionType":
+            case "UnionType":
+                for (const memberType of astType.memberTypes) {
+                    if (isPropertyRecursive(memberType)) {
+                        return true;
+                    }
+                }
+                return false;
+            case "ListType":
+            case "OptionType":
+            case "SetType":
+                return isPropertyRecursive(astType.itemType);
+        }
+    };
     for (const propertyShape of nodeShape.constraints.properties) {
         const propertyEither = this.transformPropertyShapeToAstObjectTypeProperty(propertyShape);
         if (propertyEither.isLeft()) {
@@ -176,7 +248,11 @@ export function transformNodeShapeToAstType(nodeShape) {
             continue;
             // return property;
         }
-        objectType.properties.push(propertyEither.unsafeCoerce());
+        const property = propertyEither.unsafeCoerce();
+        objectType.properties.push({
+            ...property,
+            recursive: isPropertyRecursive(property.type),
+        });
     }
     objectType.properties.sort((left, right) => {
         if (left.order < right.order) {

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstCompositeType.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,7 +7,6 @@ import * as input from "../input/index.js";
  * Try to convert a property shape to a composite type (intersection or union) using some heuristics.
  */
 export declare function transformPropertyShapeToAstCompositeType(this: ShapesGraphToAstTransformer, shape: input.Shape, inherited: {
-    defaultValue: Maybe<BlankNode | Literal | NamedNode>;
-    extern: Maybe<boolean>;
+    defaultValue: Maybe<Literal | NamedNode>;
 } | null): Either<Error, ast.Type>;
 //# sourceMappingURL=transformPropertyShapeToAstCompositeType.d.ts.map