@shaclmate/compiler 4.0.8 → 4.0.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "dependencies": {
-    "@shaclmate/shacl-ast": "4.0.8",
+    "@shaclmate/shacl-ast": "4.0.10",
     "@rdfjs/data-model": "~2.1.1",
     "@rdfjs/dataset": "~2.0.2",
     "@rdfjs/prefix-map": "~0.1.2",
@@ -19,7 +19,7 @@
     "pino": "~9.1.0",
     "plur": "~5.1.0",
     "purify-ts": "~2.1.4",
-    "rdfjs-resource": "3.0.6",
+    "rdfjs-resource": "3.0.7",
     "reserved-identifiers": "~1.0.0",
     "toposort": "2.0.2",
     "ts-invariant": "~0.10.3",
@@ -51,10 +51,8 @@
     "dist/generators/json/*.js",
     "dist/generators/ts/*.d.ts",
     "dist/generators/ts/*.js",
-    "dist/generators/ts/_ObjectType/*.d.ts",
-    "dist/generators/ts/_ObjectType/*.js",
-    "dist/generators/ts/_ObjectUnionType/*.d.ts",
-    "dist/generators/ts/_ObjectUnionType/*.js",
+    "dist/generators/ts/_NamedObjectType/*.d.ts",
+    "dist/generators/ts/_NamedObjectType/*.js",
     "dist/generators/ts/_snippets/*.d.ts",
     "dist/generators/ts/_snippets/*.js",
     "dist/input/*.d.ts",
@@ -80,5 +78,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "4.0.8"
+  "version": "4.0.10"
 }

package/dist/_ShapesGraphToAstTransformer/CurieFactory.d.ts

@@ -1,16 +0,0 @@
-import type PrefixMap from "@rdfjs/prefix-map/PrefixMap.js";
-import type { NamedNode } from "@rdfjs/types";
-import { Maybe } from "purify-ts";
-import { Curie } from "../ast/Curie.js";
-/**
- * Factory for Compact URIs (CURIEs). Tracks whether the reference part of the CURIE is unique.
- */
-export declare class CurieFactory {
-    private readonly prefixMap;
-    private readonly referenceCounts;
-    constructor({ prefixMap }: {
-        prefixMap: PrefixMap;
-    });
-    create(namedNode: NamedNode): Maybe<Curie>;
-}
-//# sourceMappingURL=CurieFactory.d.ts.map

package/dist/_ShapesGraphToAstTransformer/CurieFactory.js

@@ -1,45 +0,0 @@
-import { Maybe } from "purify-ts";
-import { invariant } from "ts-invariant";
-import { Curie } from "../ast/Curie.js";
-import { logger } from "../logger.js";
-/**
- * Factory for Compact URIs (CURIEs). Tracks whether the reference part of the CURIE is unique.
- */
-export class CurieFactory {
-    prefixMap;
-    referenceCounts = {};
-    constructor({ prefixMap }) {
-        this.prefixMap = prefixMap;
-    }
-    create(namedNode) {
-        return Maybe.fromNullable(this.prefixMap.shrink(namedNode)?.value).map((value) => {
-            const split = value.split(":", 2);
-            invariant(split.length === 2);
-            const prefix = split[0];
-            const reference = split[1];
-            if (this.referenceCounts[reference] === undefined) {
-                this.referenceCounts[reference] = {};
-            }
-            if (this.referenceCounts[reference][prefix] === undefined) {
-                this.referenceCounts[reference][prefix] = 1;
-            }
-            else {
-                this.referenceCounts[reference][prefix] += 1;
-            }
-            return new Curie({
-                hasUniqueReference: () => {
-                    const referenceCounts = this.referenceCounts[reference];
-                    if (Object.entries(referenceCounts).length === 1) {
-                        return true;
-                    }
-                    logger.debug(`duplicate local part ${reference} in ${JSON.stringify(referenceCounts)}`);
-                    return false;
-                },
-                prefix: split[0],
-                reference: split[1],
-                value: namedNode.value,
-            });
-        });
-    }
-}
-//# sourceMappingURL=CurieFactory.js.map

package/dist/_ShapesGraphToAstTransformer/NodeShapeAstType.d.ts

@@ -1,3 +0,0 @@
-import type * as ast from "../ast/index.js";
-export type NodeShapeAstType = ast.ListType | ast.ObjectIntersectionType | ast.ObjectType | ast.ObjectUnionType;
-//# sourceMappingURL=NodeShapeAstType.d.ts.map

package/dist/_ShapesGraphToAstTransformer/NodeShapeAstType.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=NodeShapeAstType.js.map

package/dist/_ShapesGraphToAstTransformer/index.d.ts

@@ -1,6 +0,0 @@
-export * from "./NodeShapeAstType.js";
-export * from "./shapeIdentifier.js";
-export * from "./transformNodeShapeToAstType.js";
-export * from "./transformPropertyShapeToAstObjectTypeProperty.js";
-export * from "./transformShapeToAstType.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/_ShapesGraphToAstTransformer/index.js

@@ -1,6 +0,0 @@
-export * from "./NodeShapeAstType.js";
-export * from "./shapeIdentifier.js";
-export * from "./transformNodeShapeToAstType.js";
-export * from "./transformPropertyShapeToAstObjectTypeProperty.js";
-export * from "./transformShapeToAstType.js";
-//# sourceMappingURL=index.js.map

package/dist/_ShapesGraphToAstTransformer/shapeIdentifier.d.ts

@@ -1,5 +0,0 @@
-import type { BlankNode, NamedNode } from "@rdfjs/types";
-import type * as input from "../input/index.js";
-import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
-export declare function shapeIdentifier(this: ShapesGraphToAstTransformer, shape: input.Shape): BlankNode | NamedNode;
-//# sourceMappingURL=shapeIdentifier.d.ts.map

package/dist/_ShapesGraphToAstTransformer/shapeIdentifier.js

@@ -1,9 +0,0 @@
-export function shapeIdentifier(shape) {
-    switch (shape.identifier.termType) {
-        case "BlankNode":
-            return shape.identifier;
-        case "NamedNode":
-            return (this.curieFactory.create(shape.identifier).extract() ?? shape.identifier);
-    }
-}
-//# sourceMappingURL=shapeIdentifier.js.map

package/dist/_ShapesGraphToAstTransformer/transformNodeShapeToAstType.d.ts

@@ -1,11 +0,0 @@
-import { Either } from "purify-ts";
-import * as ast from "../ast/index.js";
-import type * as input from "../input/index.js";
-import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
-import type { NodeShapeAstType } from "./NodeShapeAstType.js";
-export declare function transformNodeShapeToAstObjectCompoundType(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,338 +0,0 @@
-import dataFactory from "@rdfjs/data-model";
-import { rdf } from "@tpluscode/rdf-ns-builders";
-import { Either, Left, Maybe } from "purify-ts";
-import { invariant } from "ts-invariant";
-import * as ast from "../ast/index.js";
-import { Eithers } from "../Eithers.js";
-import { nodeShapeIdentifierMintingStrategy } from "./nodeShapeIdentifierMintingStrategy.js";
-import { nodeShapeTsFeatures } from "./nodeShapeTsFeatures.js";
-import { shapeNodeKinds } from "./shapeNodeKinds.js";
-const defaultNodeShapeNodeKinds = new Set([
-    "BlankNode",
-    "IRI",
-]);
-function isObjectTypePropertyRequired(property) {
-    switch (property.type.kind) {
-        case "DefaultValueType":
-            return false;
-        case "LazyObjectOptionType":
-            return false;
-        case "LazyObjectSetType":
-            return property.type.partialType.minCount > 0;
-        case "OptionType":
-            return false;
-        case "SetType":
-            return property.type.minCount > 0;
-        case "UnionType":
-            return property.type.memberTypes.every((memberType) => isObjectTypePropertyRequired({ type: memberType }));
-        case "BlankNodeType":
-        case "IdentifierType":
-        case "IriType":
-        case "LazyObjectType":
-        case "ListType":
-        case "LiteralType":
-        case "ObjectType":
-        case "ObjectUnionType":
-        case "PlaceholderType":
-        case "TermType":
-            return true;
-        case "IntersectionType":
-        case "ObjectIntersectionType":
-            throw new Error("unsupported");
-        default:
-            property.type;
-            throw new Error("should never reach this point");
-    }
-}
-const listPropertiesObjectType = new ast.ObjectType({
-    abstract: false,
-    export_: false,
-    extern: false,
-    comment: Maybe.empty(),
-    label: Maybe.empty(),
-    identifierMintingStrategy: Maybe.empty(),
-    identifierType: new ast.IdentifierType({
-        comment: Maybe.empty(),
-        label: Maybe.empty(),
-    }),
-    fromRdfType: Maybe.empty(),
-    name: Maybe.empty(),
-    toRdfTypes: [],
-    tsFeatures: new Set([]),
-    tsObjectDeclarationType: "class",
-    shapeIdentifier: dataFactory.blankNode(),
-    synthetic: true,
-    tsImports: [],
-});
-/**
- * Is an ast.ObjectType actually the shape of an RDF list?
- * If so, return the type of its rdf:first.
- */
-function transformNodeShapeToAstListType(nodeShape) {
-    invariant(nodeShape.isList);
-    return Eithers.chain3(nodeShapeIdentifierMintingStrategy(nodeShape), shapeNodeKinds(nodeShape, { defaultNodeShapeNodeKinds }), nodeShape.constraints.xone).chain(([identifierMintingStrategy, nodeKinds, xone]) => {
-        // Put a placeholder in the cache to deal with cyclic references
-        // Remove the placeholder if the transformation fails.
-        const listType = new ast.ListType({
-            comment: nodeShape.comment,
-            identifierNodeKind: nodeKinds.has("BlankNode") ? "BlankNode" : "IRI",
-            itemType: ast.PlaceholderType.instance,
-            label: nodeShape.label,
-            mutable: nodeShape.mutable.orDefault(false),
-            identifierMintingStrategy,
-            shapeIdentifier: this.shapeIdentifier(nodeShape),
-            toRdfTypes: nodeShape.toRdfTypes,
-        });
-        this.nodeShapeAstTypesByIdentifier.set(nodeShape.identifier, listType);
-        return (() => {
-            let emptyListShape;
-            let nonEmptyListShape;
-            for (const shape of xone) {
-                if (shape.constraints.hasValues.length === 1 &&
-                    shape.constraints.hasValues[0].equals(rdf.nil)) {
-                    emptyListShape = shape;
-                }
-                else if (shape.kind === "NodeShape" &&
-                    shape.constraints.properties.orDefault([]).length >= 2) {
-                    nonEmptyListShape = shape;
-                }
-            }
-            if (!emptyListShape || !nonEmptyListShape) {
-                return Left(new Error(`${nodeShape} does not have an sh:xone with exactly two shapes, one for the empty list and one for the non-empty list`));
-            }
-            return nonEmptyListShape.constraints.properties.chain((nonEmptyListShapeProperties) => {
-                let firstPropertyShape;
-                let restPropertyShape;
-                for (const propertyShape of nonEmptyListShapeProperties) {
-                    if (propertyShape.path.termType !== "NamedNode") {
-                        continue;
-                    }
-                    if (propertyShape.path.equals(rdf.first)) {
-                        firstPropertyShape = propertyShape;
-                    }
-                    else if (propertyShape.path.equals(rdf.rest)) {
-                        restPropertyShape = propertyShape;
-                    }
-                }
-                if (!firstPropertyShape) {
-                    return Left(new Error(`${nodeShape} has a non-empty list shape without an sh:property shape whose sh:path is rdf:first`));
-                }
-                if (firstPropertyShape.constraints.maxCount.extract() !== 1 ||
-                    firstPropertyShape.constraints.minCount.extract() !== 1) {
-                    return Left(new Error(`${nodeShape} non-empty list shape rdf:first property shape does not have sh:maxCount=1 and/or sh:minCount=1`));
-                }
-                if (!restPropertyShape) {
-                    return Left(new Error(`${nodeShape} has a non-empty list shape without an sh:property shape whose sh:path is rdf:rest`));
-                }
-                if (restPropertyShape.constraints.maxCount.extract() !== 1 ||
-                    restPropertyShape.constraints.minCount.extract() !== 1) {
-                    return Left(new Error(`${nodeShape} non-empty list shape rdf:rest property shape does not have sh:maxCount=1 and/or sh:minCount=1`));
-                }
-                return this.transformPropertyShapeToAstObjectTypeProperty({
-                    // Just need a dummy ast.ObjectType here to get the properties transformed.
-                    objectType: listPropertiesObjectType,
-                    propertyShape: firstPropertyShape,
-                }).chain((firstProperty) => {
-                    if (!ast.ListType.isItemType(firstProperty.type)) {
-                        return Left(new Error(`${nodeShape}: ${firstProperty.type.kind} is not a valid list item type`));
-                    }
-                    listType.itemType = firstProperty.type;
-                    return this.transformPropertyShapeToAstObjectTypeProperty({
-                        // Just need a dummy ast.ObjectType here to get the properties transformed.
-                        objectType: listPropertiesObjectType,
-                        propertyShape: restPropertyShape,
-                    }).chain((restProperty) => {
-                        if (restProperty.type.kind !== "ListType" ||
-                            !restProperty.type.shapeIdentifier.equals(nodeShape.identifier)) {
-                            return Left(new Error(`${nodeShape} rdf:rest property is not recursive into the node shape`));
-                        }
-                        return Either.of(listType);
-                    });
-                });
-            });
-        })().ifLeft(() => {
-            this.nodeShapeAstTypesByIdentifier.delete(nodeShape.identifier);
-        });
-    });
-}
-export function transformNodeShapeToAstObjectCompoundType({ export_, nodeShape, }) {
-    return Eithers.chain3(nodeShape.constraints.and, nodeShapeTsFeatures.bind(this)(nodeShape), nodeShape.constraints.xone).chain(([andShapes, tsFeatures, xoneShapes]) => {
-        let compoundTypeShapes;
-        let compoundTypeKind;
-        if (andShapes.length > 0) {
-            compoundTypeShapes = andShapes;
-            compoundTypeKind = "ObjectIntersectionType";
-        }
-        else if (xoneShapes.length > 0) {
-            compoundTypeShapes = xoneShapes;
-            compoundTypeKind = "ObjectUnionType";
-        }
-        else {
-            throw new Error("should never be reached");
-        }
-        const compoundTypeNodeShapes = [];
-        for (const compoundTypeShape of compoundTypeShapes) {
-            if (compoundTypeShape.kind !== "NodeShape") {
-                return Left(new Error(`${nodeShape} has non-NodeShape in its logical constraint`));
-            }
-            compoundTypeNodeShapes.push(compoundTypeShape);
-        }
-        if (compoundTypeNodeShapes.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 compoundType = new (compoundTypeKind === "ObjectIntersectionType"
-            ? ast.ObjectIntersectionType
-            : ast.ObjectUnionType)({
-            comment: nodeShape.comment,
-            export_,
-            label: nodeShape.label,
-            name: nodeShape.shaclmateName,
-            shapeIdentifier: this.shapeIdentifier(nodeShape),
-            tsFeatures,
-        });
-        this.nodeShapeAstTypesByIdentifier.set(nodeShape.identifier, compoundType);
-        return Either.sequence(compoundTypeNodeShapes.map((memberNodeShape) => this.transformNodeShapeToAstType(memberNodeShape).chain((memberType) => compoundType.addMemberType(memberType))))
-            .map(() => compoundType)
-            .ifLeft(() => {
-            this.nodeShapeAstTypesByIdentifier.delete(nodeShape.identifier);
-        });
-    });
-}
-export function transformNodeShapeToAstType(nodeShape) {
-    {
-        const type = this.nodeShapeAstTypesByIdentifier.get(nodeShape.identifier);
-        if (type) {
-            return Either.of(type);
-        }
-    }
-    if (nodeShape.isList) {
-        return transformNodeShapeToAstListType.bind(this)(nodeShape);
-    }
-    return Eithers.chain11(nodeShape.ancestorNodeShapes, nodeShape.childNodeShapes, nodeShape.descendantNodeShapes, nodeShape.parentNodeShapes, nodeShape.constraints.and, nodeShapeIdentifierMintingStrategy(nodeShape), shapeNodeKinds(nodeShape, { defaultNodeShapeNodeKinds }), nodeShape.constraints.properties, nodeShapeTsFeatures.bind(this)(nodeShape), nodeShape.tsObjectDeclarationType.isJust()
-        ? Either.of(nodeShape.tsObjectDeclarationType)
-        : nodeShape.isDefinedBy.map((ontology) => ontology.chain((ontology) => ontology.tsObjectDeclarationType)), nodeShape.constraints.xone).chain(([ancestorNodeShapes, childNodeShapes, descendantNodeShapes, parentNodeShapes, andShapes, identifierMintingStrategy, nodeKinds, propertyShapes, tsFeatures, tsObjectDeclarationType, xoneShapes,]) => {
-        const abstract = nodeShape.abstract.orDefault(false);
-        const export_ = nodeShape.export.orDefault(true);
-        if (andShapes.length > 0 || xoneShapes.length > 0) {
-            return transformNodeShapeToAstObjectCompoundType.bind(this)({
-                export_,
-                nodeShape,
-            });
-        }
-        let fromRdfType;
-        let toRdfTypes;
-        if (!abstract) {
-            fromRdfType = nodeShape.fromRdfType.alt(nodeShape.rdfType);
-            if (nodeShape.isClass &&
-                nodeShape.identifier.termType === "NamedNode") {
-                fromRdfType = fromRdfType.alt(Maybe.of(nodeShape.identifier));
-            }
-            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);
-                }
-            });
-        }
-        else {
-            fromRdfType = Maybe.empty();
-            toRdfTypes = [];
-        }
-        if (nodeKinds.has("Literal")) {
-            return Left(new Error(`${nodeShape} should not have a nodeKind "Literal"`));
-        }
-        let identifierType;
-        if (nodeKinds.size === 2) {
-            invariant(nodeShape.identifierIn.length === 0);
-            identifierType = new ast.IdentifierType({
-                comment: Maybe.empty(),
-                label: Maybe.empty(),
-            });
-        }
-        else {
-            switch ([...nodeKinds][0]) {
-                case "BlankNode":
-                    invariant(nodeShape.identifierIn.length === 0);
-                    identifierType = new ast.BlankNodeType({
-                        comment: Maybe.empty(),
-                        label: Maybe.empty(),
-                    });
-                    break;
-                case "IRI":
-                    identifierType = new ast.IriType({
-                        comment: Maybe.empty(),
-                        hasValues: [],
-                        in_: nodeShape.identifierIn,
-                        label: Maybe.empty(),
-                    });
-                    break;
-                case "Literal":
-                    throw new Error("should never happen");
-            }
-        }
-        // Put a placeholder in the cache to deal with cyclic references
-        // Remove the placeholder if the transformation fails.
-        // If this node shape's properties (directly or indirectly) refer to the node shape itself,
-        // we'll return this placeholder.
-        const objectType = new ast.ObjectType({
-            abstract,
-            comment: nodeShape.comment,
-            export_: export_,
-            extern: nodeShape.extern.orDefault(false),
-            fromRdfType,
-            label: nodeShape.label,
-            identifierType,
-            identifierMintingStrategy,
-            name: nodeShape.shaclmateName,
-            shapeIdentifier: this.shapeIdentifier(nodeShape),
-            synthetic: false,
-            toRdfTypes,
-            tsFeatures,
-            tsImports: nodeShape.tsImports,
-            tsObjectDeclarationType: tsObjectDeclarationType.orDefault("class"),
-        });
-        this.nodeShapeAstTypesByIdentifier.set(nodeShape.identifier, objectType);
-        return (() => {
-            // Populate ancestor and descendant object types
-            const relatedObjectTypes = (relatedNodeShapes) => {
-                return relatedNodeShapes.flatMap((relatedNodeShape) => this.transformNodeShapeToAstType(relatedNodeShape)
-                    .toMaybe()
-                    .filter((astType) => astType.kind === "ObjectType")
-                    .toList());
-            };
-            objectType.addAncestorObjectTypes(...relatedObjectTypes(ancestorNodeShapes));
-            objectType.addChildObjectTypes(...relatedObjectTypes(childNodeShapes));
-            objectType.addDescendantObjectTypes(...relatedObjectTypes(descendantNodeShapes));
-            objectType.addParentObjectTypes(...relatedObjectTypes(parentNodeShapes));
-            // Populate properties
-            for (const propertyShape of propertyShapes) {
-                const propertyEither = this.transformPropertyShapeToAstObjectTypeProperty({
-                    objectType,
-                    propertyShape,
-                });
-                if (propertyEither.isLeft()) {
-                    return propertyEither;
-                }
-                propertyEither.ifRight((property) => {
-                    objectType.addProperties(property);
-                });
-            }
-            if (!objectType.abstract &&
-                !objectType.extern &&
-                objectType.fromRdfType.isNothing() &&
-                !objectType.properties.some(isObjectTypePropertyRequired)) {
-                return Left(new Error(`${nodeShape} has no required properties and no implicitly required rdf:type`));
-            }
-            objectType.sortProperties();
-            return Either.of(objectType);
-        })().ifLeft(() => {
-            this.nodeShapeAstTypesByIdentifier.delete(nodeShape.identifier);
-        });
-    });
-}
-//# sourceMappingURL=transformNodeShapeToAstType.js.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstAbstractTypeProperties.d.ts

@@ -1,12 +0,0 @@
-import { Either, Maybe } from "purify-ts";
-import type * as input from "../input/index.js";
-type AstAbstractTypeProperties = {
-    readonly comment: Maybe<string>;
-    readonly label: Maybe<string>;
-};
-declare namespace AstAbstractTypeProperties {
-    const empty: AstAbstractTypeProperties;
-}
-export declare function transformShapeToAstAbstractTypeProperties(shape: input.Shape): Either<Error, AstAbstractTypeProperties>;
-export {};
-//# sourceMappingURL=transformShapeToAstAbstractTypeProperties.d.ts.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstAbstractTypeProperties.js

@@ -1,31 +0,0 @@
-import { Either, Maybe } from "purify-ts";
-var AstAbstractTypeProperties;
-(function (AstAbstractTypeProperties) {
-    AstAbstractTypeProperties.empty = {
-        comment: Maybe.empty(),
-        label: Maybe.empty(),
-    };
-})(AstAbstractTypeProperties || (AstAbstractTypeProperties = {}));
-export function transformShapeToAstAbstractTypeProperties(shape) {
-    if (shape.kind === "PropertyShape") {
-        // comment, label, et al. belong to the ObjectType.Property, not to the type
-        return Either.of(AstAbstractTypeProperties.empty);
-    }
-    return shape.constraints.properties.chain((properties) => {
-        if (properties.length > 0) {
-            // comment, label, et al. belong to the ObjectType, not to the type
-            return Either.of(AstAbstractTypeProperties.empty);
-        }
-        return shape.constraints.xone.map((xone) => {
-            if (xone.length > 0) {
-                // comment, label, et al. belong to the ObjectType, not to the type
-                return AstAbstractTypeProperties.empty;
-            }
-            return {
-                comment: shape.comment,
-                label: shape.label,
-            };
-        });
-    });
-}
-//# sourceMappingURL=transformShapeToAstAbstractTypeProperties.js.map

package/dist/ast/AbstractObjectCompoundType.d.ts

@@ -1,45 +0,0 @@
-import type { BlankNode, NamedNode } from "@rdfjs/types";
-import { Either, Maybe } from "purify-ts";
-import type { TsFeature } from "../enums/TsFeature.js";
-import { AbstractCompoundType } from "./AbstractCompoundType.js";
-import { BlankNodeType } from "./BlankNodeType.js";
-import { IdentifierType } from "./IdentifierType.js";
-import { IriType } from "./IriType.js";
-import type { ObjectIntersectionType } from "./ObjectIntersectionType.js";
-import type { ObjectType } from "./ObjectType.js";
-import type { ObjectUnionType } from "./ObjectUnionType.js";
-import type { Type } from "./Type.js";
-/**
- * Abstract base class for a compound of object types, such as an intersection or union.
- */
-export declare abstract class AbstractObjectCompoundType<ObjectCompoundTypeT extends ObjectIntersectionType | ObjectUnionType> extends AbstractCompoundType<ObjectCompoundTypeT | ObjectType> {
-    #private;
-    /**
-     * Should generated code derived from this type be visible outside its module?
-     *
-     * Defaults to true.
-     */
-    readonly export: boolean;
-    abstract readonly kind: "ObjectIntersectionType" | "ObjectUnionType";
-    /**
-     * Name of this type, from shaclmate:name.
-     */
-    readonly name: Maybe<string>;
-    /**
-     * Identifier of the shape this ObjectType was derived from.
-     */
-    readonly shapeIdentifier: BlankNode | NamedNode;
-    constructor({ export_, name, shapeIdentifier, tsFeatures, ...superParameters }: {
-        export_: boolean;
-        name: Maybe<string>;
-        shapeIdentifier: BlankNode | NamedNode;
-        tsFeatures: ReadonlySet<TsFeature>;
-    } & ConstructorParameters<typeof AbstractCompoundType<ObjectCompoundTypeT | ObjectType>>[0]);
-    equals(other: AbstractObjectCompoundType<ObjectCompoundTypeT>): boolean;
-    get identifierType(): BlankNodeType | IdentifierType | IriType;
-    get memberObjectTypes(): readonly ObjectType[];
-    get tsFeatures(): ReadonlySet<TsFeature>;
-    addMemberType(memberType: Type): Either<Error, void>;
-    toString(): string;
-}
-//# sourceMappingURL=AbstractObjectCompoundType.d.ts.map