@shaclmate/compiler 4.0.7 → 4.0.9

package/dist/ast/AbstractContainerType.js

@@ -14,6 +14,9 @@ export class AbstractContainerType extends AbstractType {
         super(superParameters);
         this.itemType = itemType;
     }
+    get recursive() {
+        return this.itemType.recursive;
+    }
     equals(other) {
         if (!super.equals(other)) {
             return false;
@@ -36,9 +39,7 @@ export class AbstractContainerType extends AbstractType {
             case "IriType":
             case "ListType":
             case "LiteralType":
-            case "ObjectIntersectionType":
             case "ObjectType":
-            case "ObjectUnionType":
             case "TermType":
             case "UnionType":
                 return true;
@@ -49,8 +50,6 @@ export class AbstractContainerType extends AbstractType {
             case "OptionType":
             case "SetType":
                 return false;
-            case "PlaceholderType":
-                throw new Error("should never happen");
         }
     }
     AbstractContainerType.isItemType = isItemType;

package/dist/ast/AbstractLazyObjectType.d.ts

@@ -14,6 +14,7 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
         partialType: PartialTypeT;
         resolveType: ResolveTypeT;
     } & ConstructorParameters<typeof AbstractType>[0]);
+    get recursive(): boolean;
     equals(other: AbstractLazyObjectType<PartialTypeT, ResolveTypeT>): boolean;
     toString(): string;
 }

package/dist/ast/AbstractLazyObjectType.js

@@ -11,6 +11,9 @@ export class AbstractLazyObjectType extends AbstractType {
         this.partialType = partialType;
         this.resolveType = resolveType;
     }
+    get recursive() {
+        return this.partialType.recursive;
+    }
     equals(other) {
         if (!super.equals(other)) {
             return false;

package/dist/ast/AbstractTermType.d.ts

@@ -14,6 +14,7 @@ export declare abstract class AbstractTermType<ConstantTermT extends Literal | N
     readonly in_: readonly ConstantTermT[];
     abstract readonly kind: "BlankNodeType" | "IdentifierType" | "IriType" | "LiteralType" | "TermType";
     abstract readonly nodeKinds: ReadonlySet<NodeKind>;
+    readonly recursive = false;
     constructor({ hasValues, in_, ...superParameters }: {
         hasValues: readonly ConstantTermT[];
         in_: readonly ConstantTermT[];

package/dist/ast/AbstractTermType.js

@@ -11,6 +11,7 @@ import { arrayEquals, setEquals, strictEquals, termEquals } from "./equals.js";
 export class AbstractTermType extends AbstractType {
     hasValues;
     in_;
+    recursive = false;
     constructor({ hasValues, in_, ...superParameters }) {
         super(superParameters);
         this.hasValues = hasValues;

package/dist/ast/AbstractType.d.ts

@@ -1,3 +1,4 @@
+import type { BlankNode, NamedNode } from "@rdfjs/types";
 import { Maybe } from "purify-ts";
 /**
  * Abstract base class for Types.
@@ -11,9 +12,23 @@ export declare abstract class AbstractType {
      * Human-readable label from rdfs:label.
      */
     readonly label: Maybe<string>;
-    constructor({ comment, label, }: {
+    /**
+     * Name of this type, from shaclmate:name or sh:name.
+     */
+    readonly name: Maybe<string>;
+    /**
+     * Does this type directly or indirectly reference itself?
+     */
+    abstract readonly recursive: boolean;
+    /**
+     * Identifier of the shape this type was derived from.
+     */
+    readonly shapeIdentifier: BlankNode | NamedNode;
+    constructor({ comment, label, name, shapeIdentifier, }: {
         comment: Maybe<string>;
         label: Maybe<string>;
+        name: Maybe<string>;
+        shapeIdentifier: BlankNode | NamedNode;
     });
     equals(other: AbstractType): boolean;
     abstract toString(): string;

package/dist/ast/AbstractType.js

@@ -12,9 +12,19 @@ export class AbstractType {
      * Human-readable label from rdfs:label.
      */
     label = Maybe.empty();
-    constructor({ comment, label, }) {
+    /**
+     * Name of this type, from shaclmate:name or sh:name.
+     */
+    name;
+    /**
+     * Identifier of the shape this type was derived from.
+     */
+    shapeIdentifier;
+    constructor({ comment, label, name, shapeIdentifier, }) {
         this.comment = comment;
         this.label = label;
+        this.name = name;
+        this.shapeIdentifier = shapeIdentifier;
     }
     equals(other) {
         if (!maybeEquals(strictEquals)(this.comment, other.comment)) {

package/dist/ast/Ast.d.ts

@@ -1,9 +1,9 @@
-import type { ObjectIntersectionType } from "./ObjectIntersectionType.js";
+import type { IntersectionType } from "./IntersectionType.js";
 import type { ObjectType } from "./ObjectType.js";
-import type { ObjectUnionType } from "./ObjectUnionType.js";
+import type { UnionType } from "./UnionType.js";
 export interface Ast {
-    readonly objectIntersectionTypes: readonly ObjectIntersectionType[];
+    readonly namedIntersectionTypes: readonly IntersectionType[];
+    readonly namedUnionTypes: readonly UnionType[];
     readonly objectTypes: readonly ObjectType[];
-    readonly objectUnionTypes: readonly ObjectUnionType[];
 }
 //# sourceMappingURL=Ast.d.ts.map

package/dist/ast/BlankNodeType.d.ts

@@ -6,6 +6,6 @@ import { AbstractTermType } from "./AbstractTermType.js";
 export declare class BlankNodeType extends AbstractTermType<NamedNode, BlankNode> {
     readonly kind = "BlankNodeType";
     readonly nodeKinds: ReadonlySet<"BlankNode">;
-    constructor(superParameters: Pick<ConstructorParameters<typeof AbstractTermType<NamedNode, BlankNode>>[0], "comment" | "label">);
+    constructor(superParameters: Pick<ConstructorParameters<typeof AbstractTermType<NamedNode, BlankNode>>[0], "comment" | "label" | "name" | "shapeIdentifier">);
 }
 //# sourceMappingURL=BlankNodeType.d.ts.map

package/dist/ast/DefaultValueType.d.ts

@@ -1,7 +1,6 @@
 import type { Literal, NamedNode } from "@rdfjs/types";
 import { AbstractContainerType } from "./AbstractContainerType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
-import type { PlaceholderType } from "./PlaceholderType.js";
 import type { Type } from "./Type.js";
 /**
  * A type with an sh:defaultValue.
@@ -20,7 +19,7 @@ export declare class DefaultValueType<ItemTypeT extends DefaultValueType.ItemTyp
     equals(other: DefaultValueType<ItemTypeT>): boolean;
 }
 export declare namespace DefaultValueType {
-    type ItemType = Exclude<AbstractContainerType.ItemType, BlankNodeType | PlaceholderType>;
+    type ItemType = Exclude<AbstractContainerType.ItemType, BlankNodeType>;
     function isItemType(type: Type): type is ItemType;
 }
 //# sourceMappingURL=DefaultValueType.d.ts.map

package/dist/ast/DefaultValueType.js

@@ -16,6 +16,8 @@ export class DefaultValueType extends AbstractContainerType {
             comment: itemType.comment,
             itemType,
             label: itemType.label,
+            name: itemType.name,
+            shapeIdentifier: itemType.shapeIdentifier,
         });
         this.defaultValue = defaultValue;
     }

package/dist/ast/IdentifierType.d.ts

@@ -7,6 +7,6 @@ import { AbstractTermType } from "./AbstractTermType.js";
 export declare class IdentifierType extends AbstractTermType<NamedNode, BlankNode | NamedNode> {
     readonly kind = "IdentifierType";
     readonly nodeKinds: ReadonlySet<IdentifierNodeKind>;
-    constructor(superParameters: Pick<ConstructorParameters<typeof AbstractTermType<NamedNode, BlankNode>>[0], "comment" | "label">);
+    constructor(superParameters: Pick<ConstructorParameters<typeof AbstractTermType<NamedNode, BlankNode>>[0], "comment" | "label" | "name" | "shapeIdentifier">);
 }
 //# sourceMappingURL=IdentifierType.d.ts.map

package/dist/ast/IntersectionType.d.ts

@@ -1,9 +1,14 @@
 import { AbstractCompoundType } from "./AbstractCompoundType.js";
-import type { Type } from "./Type.js";
+import type { ObjectIntersectionType } from "./ObjectIntersectionType.js";
 /**
  * A conjunction ("and") of types, corresponding to an sh:and.
  */
-export declare class IntersectionType extends AbstractCompoundType<Type> {
+export declare class IntersectionType<MemberTypeT extends IntersectionType.MemberType = IntersectionType.MemberType> extends AbstractCompoundType<AbstractCompoundType.Member<MemberTypeT>, MemberTypeT> {
     readonly kind = "IntersectionType";
+    isObjectIntersectionType(): this is ObjectIntersectionType;
+}
+export declare namespace IntersectionType {
+    type MemberType = AbstractCompoundType.MemberType;
+    const isMemberType: typeof AbstractCompoundType.isMemberType;
 }
 //# sourceMappingURL=IntersectionType.d.ts.map

package/dist/ast/IntersectionType.js

@@ -4,5 +4,13 @@ import { AbstractCompoundType } from "./AbstractCompoundType.js";
  */
 export class IntersectionType extends AbstractCompoundType {
     kind = "IntersectionType";
+    isObjectIntersectionType() {
+        return this.members.every((member) => member.type.kind === "ObjectType" ||
+            (member.type.kind === "IntersectionType" &&
+                member.type.isObjectIntersectionType()));
+    }
 }
+(function (IntersectionType) {
+    IntersectionType.isMemberType = AbstractCompoundType.isMemberType;
+})(IntersectionType || (IntersectionType = {}));
 //# sourceMappingURL=IntersectionType.js.map

package/dist/ast/ListType.d.ts

@@ -8,10 +8,7 @@ import type { IdentifierType } from "./IdentifierType.js";
 import type { IntersectionType } from "./IntersectionType.js";
 import type { IriType } from "./IriType.js";
 import type { LiteralType } from "./LiteralType.js";
-import type { ObjectIntersectionType } from "./ObjectIntersectionType.js";
 import type { ObjectType } from "./ObjectType.js";
-import type { ObjectUnionType } from "./ObjectUnionType.js";
-import type { PlaceholderType } from "./PlaceholderType.js";
 import type { TermType } from "./TermType.js";
 import type { Type } from "./Type.js";
 import type { UnionType } from "./UnionType.js";
@@ -32,10 +29,6 @@ export declare class ListType<ItemTypeT extends ListType.ItemType = ListType.Ite
      * Strategy for minting new list and sub-list identifiers.
      */
     readonly identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
-    /**
-     * Identifier of the node shape this type was derived from.
-     */
-    readonly shapeIdentifier: BlankNode | NamedNode;
     /**
      * rdf:type's that will be added to this object when it's serialized toRdf.
      *
@@ -43,7 +36,7 @@ export declare class ListType<ItemTypeT extends ListType.ItemType = ListType.Ite
      * class targets).
      */
     readonly toRdfTypes: readonly NamedNode[];
-    constructor({ identifierMintingStrategy, identifierNodeKind, shapeIdentifier, toRdfTypes, ...superParameters }: {
+    constructor({ identifierMintingStrategy, identifierNodeKind, toRdfTypes, ...superParameters }: {
         identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
         identifierNodeKind: IdentifierNodeKind;
         shapeIdentifier: BlankNode | NamedNode;
@@ -52,7 +45,7 @@ export declare class ListType<ItemTypeT extends ListType.ItemType = ListType.Ite
     equals(other: ListType<ItemTypeT>): boolean;
 }
 export declare namespace ListType {
-    type ItemType = BlankNodeType | IdentifierType | IntersectionType | IriType | LiteralType | ObjectIntersectionType | ObjectType | ObjectUnionType | PlaceholderType | TermType | UnionType;
+    type ItemType = BlankNodeType | IdentifierType | IntersectionType | IriType | LiteralType | ObjectType | TermType | UnionType;
     function isItemType(type: Type): type is ItemType;
 }
 //# sourceMappingURL=ListType.d.ts.map

package/dist/ast/ListType.js

@@ -16,10 +16,6 @@ export class ListType extends AbstractCollectionType {
      * Strategy for minting new list and sub-list identifiers.
      */
     identifierMintingStrategy;
-    /**
-     * Identifier of the node shape this type was derived from.
-     */
-    shapeIdentifier;
     /**
      * rdf:type's that will be added to this object when it's serialized toRdf.
      *
@@ -27,11 +23,10 @@ export class ListType extends AbstractCollectionType {
      * class targets).
      */
     toRdfTypes;
-    constructor({ identifierMintingStrategy, identifierNodeKind, shapeIdentifier, toRdfTypes, ...superParameters }) {
+    constructor({ identifierMintingStrategy, identifierNodeKind, toRdfTypes, ...superParameters }) {
         super(superParameters);
         this.identifierMintingStrategy = identifierMintingStrategy;
         this.identifierNodeKind = identifierNodeKind;
-        this.shapeIdentifier = shapeIdentifier;
         this.toRdfTypes = toRdfTypes;
     }
     equals(other) {
@@ -47,10 +42,7 @@ export class ListType extends AbstractCollectionType {
             case "IntersectionType":
             case "IriType":
             case "LiteralType":
-            case "ObjectIntersectionType":
             case "ObjectType":
-            case "ObjectUnionType":
-            case "PlaceholderType":
             case "TermType":
             case "UnionType":
                 return true;

package/dist/ast/LiteralType.d.ts

@@ -18,6 +18,7 @@ export declare class LiteralType extends AbstractTermType<Literal, Literal> {
         minExclusive: Maybe<Literal>;
         minInclusive: Maybe<Literal>;
     } & Omit<ConstructorParameters<typeof AbstractTermType<Literal, Literal>>[0], "nodeKinds">);
+    equals(other: AbstractTermType<Literal, Literal>): boolean;
     toString(): string;
 }
 //# sourceMappingURL=LiteralType.d.ts.map

package/dist/ast/LiteralType.js

@@ -1,4 +1,5 @@
 import { AbstractTermType } from "./AbstractTermType.js";
+import { arrayEquals, maybeEquals, strictEquals, termEquals, } from "./equals.js";
 export class LiteralType extends AbstractTermType {
     datatype;
     kind = "LiteralType";
@@ -17,6 +18,31 @@ export class LiteralType extends AbstractTermType {
         this.minExclusive = minExclusive;
         this.minInclusive = minInclusive;
     }
+    equals(other) {
+        if (!super.equals(other)) {
+            return false;
+        }
+        const otherLiteralType = other;
+        if (!maybeEquals(termEquals)(this.datatype, otherLiteralType.datatype)) {
+            return false;
+        }
+        if (!arrayEquals(strictEquals)(this.languageIn, otherLiteralType.languageIn)) {
+            return false;
+        }
+        if (!maybeEquals(termEquals)(this.maxExclusive, otherLiteralType.maxExclusive)) {
+            return false;
+        }
+        if (!maybeEquals(termEquals)(this.maxInclusive, otherLiteralType.maxInclusive)) {
+            return false;
+        }
+        if (!maybeEquals(termEquals)(this.minExclusive, otherLiteralType.minExclusive)) {
+            return false;
+        }
+        if (!maybeEquals(termEquals)(this.minInclusive, otherLiteralType.minInclusive)) {
+            return false;
+        }
+        return true;
+    }
     toString() {
         return `${this.kind}()`;
     }

package/dist/ast/ObjectCompoundType.d.ts

@@ -0,0 +1,12 @@
+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";
+export type ObjectCompoundType = ObjectIntersectionType | ObjectUnionType;
+export declare namespace ObjectCompoundType {
+    function identifierType(objectCompoundType: ObjectCompoundType): BlankNodeType | IdentifierType | IriType;
+    function memberObjectTypes(objectCompoundType: ObjectCompoundType): readonly ObjectType[];
+}
+//# sourceMappingURL=ObjectCompoundType.d.ts.map

package/dist/ast/ObjectCompoundType.js

@@ -0,0 +1,88 @@
+import TermSet from "@rdfjs/term-set";
+import { Maybe } from "purify-ts";
+import { Resource } from "rdfjs-resource";
+import { invariant } from "ts-invariant";
+import { BlankNodeType } from "./BlankNodeType.js";
+import { IdentifierType } from "./IdentifierType.js";
+import { IriType } from "./IriType.js";
+export var ObjectCompoundType;
+(function (ObjectCompoundType) {
+    function identifierType(objectCompoundType) {
+        const memberIdentifierTypeNodeKinds = new Set();
+        const memberIdentifierTypesIn = new TermSet();
+        for (const memberType of memberObjectTypes(objectCompoundType)) {
+            for (const nodeKind of memberType.identifierType.nodeKinds) {
+                memberIdentifierTypeNodeKinds.add(nodeKind);
+            }
+            for (const in_ of memberType.identifierType.in_) {
+                memberIdentifierTypesIn.add(in_);
+            }
+        }
+        invariant(memberIdentifierTypeNodeKinds.size > 0);
+        if (memberIdentifierTypeNodeKinds.size === 2) {
+            return new IdentifierType({
+                comment: Maybe.empty(),
+                label: Maybe.empty(),
+                name: Maybe.empty(),
+                shapeIdentifier: objectCompoundType.shapeIdentifier,
+            });
+        }
+        const memberIdentifierTypeNodeKind = [...memberIdentifierTypeNodeKinds][0];
+        switch (memberIdentifierTypeNodeKind) {
+            case "BlankNode":
+                return new BlankNodeType({
+                    comment: Maybe.empty(),
+                    label: Maybe.empty(),
+                    name: Maybe.empty(),
+                    shapeIdentifier: objectCompoundType.shapeIdentifier,
+                });
+            case "IRI":
+                return new IriType({
+                    comment: Maybe.empty(),
+                    hasValues: [],
+                    in_: [...memberIdentifierTypesIn],
+                    label: Maybe.empty(),
+                    name: Maybe.empty(),
+                    shapeIdentifier: objectCompoundType.shapeIdentifier,
+                });
+            default:
+                memberIdentifierTypeNodeKind;
+                throw new Error("should never reach here");
+        }
+    }
+    ObjectCompoundType.identifierType = identifierType;
+    function memberObjectTypes(objectCompoundType) {
+        const memberObjectTypes_ = [];
+        for (const member of objectCompoundType.members) {
+            switch (member.type.kind) {
+                case "ObjectType":
+                    memberObjectTypes_.push(member.type);
+                    break;
+                case "IntersectionType":
+                case "UnionType": {
+                    invariant(member.type.kind === objectCompoundType.kind);
+                    memberObjectTypes_.push(...memberObjectTypes(member.type));
+                    break;
+                }
+            }
+        }
+        invariant(memberObjectTypes_.length >= objectCompoundType.members.length, "object compound type has no member ObjectType's");
+        // Member object types must have distinct RDF types or no RDF types at all.
+        const fromRdfTypes = new TermSet();
+        let expectUniqueFromRdfTypesCount = 0;
+        for (const memberObjectType of memberObjectTypes_) {
+            if (memberObjectType.extern) {
+                continue;
+            }
+            expectUniqueFromRdfTypesCount++;
+            memberObjectType.fromRdfType.ifJust((fromRdfType) => fromRdfTypes.add(fromRdfType));
+        }
+        if (fromRdfTypes.size > 0 &&
+            fromRdfTypes.size !== expectUniqueFromRdfTypesCount) {
+            throw new Error(`one or more ${objectCompoundType} members ([${memberObjectTypes_.map((memberType) => memberType.toString()).join(", ")}]) lack distinguishing fromRdfType's ({${[...fromRdfTypes].map((fromRdfType) => Resource.Identifier.toString(fromRdfType)).join(", ")}})`);
+        }
+        return memberObjectTypes_;
+    }
+    ObjectCompoundType.memberObjectTypes = memberObjectTypes;
+})(ObjectCompoundType || (ObjectCompoundType = {}));
+//# sourceMappingURL=ObjectCompoundType.js.map

package/dist/ast/ObjectIntersectionType.d.ts

@@ -1,8 +1,4 @@
-import { AbstractObjectCompoundType } from "./AbstractObjectCompoundType.js";
-/**
- * A conjunction/intersection of object types, corresponding to an sh:and on a node shape.
- */
-export declare class ObjectIntersectionType extends AbstractObjectCompoundType<ObjectIntersectionType> {
-    readonly kind = "ObjectIntersectionType";
-}
+import type { IntersectionType } from "./IntersectionType.js";
+import type { ObjectType } from "./ObjectType.js";
+export type ObjectIntersectionType = IntersectionType<IntersectionType<ObjectType> | ObjectType>;
 //# sourceMappingURL=ObjectIntersectionType.d.ts.map

package/dist/ast/ObjectIntersectionType.js

@@ -1,8 +1,2 @@
-import { AbstractObjectCompoundType } from "./AbstractObjectCompoundType.js";
-/**
- * A conjunction/intersection of object types, corresponding to an sh:and on a node shape.
- */
-export class ObjectIntersectionType extends AbstractObjectCompoundType {
-    kind = "ObjectIntersectionType";
-}
+export {};
 //# sourceMappingURL=ObjectIntersectionType.js.map

package/dist/ast/ObjectType.d.ts

@@ -7,7 +7,6 @@ import type { TsFeature } from "../enums/TsFeature.js";
 import type { TsObjectDeclarationType } from "../enums/TsObjectDeclarationType.js";
 import { AbstractType } from "./AbstractType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
-import type { Curie } from "./Curie.js";
 import type { IdentifierType } from "./IdentifierType.js";
 import type { IriType } from "./IriType.js";
 import { Type } from "./Type.js";
@@ -19,12 +18,6 @@ export declare class ObjectType extends AbstractType {
      * Defaults to false.
      */
     readonly abstract: boolean;
-    /**
-     * Should generated code derived from this ObjectType be visible outside its module?
-     *
-     * Defaults to true.
-     */
-    readonly export: boolean;
     /**
      * If true, the code for this ObjectType is defined externally and should not be generated.
      *
@@ -50,14 +43,6 @@ export declare class ObjectType extends AbstractType {
      * Type discriminant.
      */
     readonly kind = "ObjectType";
-    /**
-     * Name of this type, from shaclmate:name.
-     */
-    readonly name: Maybe<string>;
-    /**
-     * Identifier of the shape this ObjectType was derived from.
-     */
-    readonly shapeIdentifier: BlankNode | NamedNode;
     /**
      * Was this type synthesized or did it come from SHACL?
      */
@@ -86,31 +71,29 @@ export declare class ObjectType extends AbstractType {
      * Whether to generate a TypeScript class or interface for this type.
      */
     readonly tsObjectDeclarationType: TsObjectDeclarationType;
-    constructor({ abstract, export_, extern, fromRdfType, identifierMintingStrategy, identifierType, name, shapeIdentifier, synthetic, toRdfTypes, tsFeatures, tsImports, tsObjectDeclarationType, ...superParameters }: {
+    constructor({ abstract, extern, fromRdfType, identifierMintingStrategy, identifierType, synthetic, toRdfTypes, tsFeatures, tsImports, tsObjectDeclarationType, ...superParameters }: {
         abstract: boolean;
-        export_: boolean;
         extern: boolean;
         fromRdfType: Maybe<NamedNode>;
         identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
         identifierType: BlankNodeType | IdentifierType | IriType;
-        name: Maybe<string>;
-        shapeIdentifier: BlankNode | Curie | NamedNode;
         synthetic: boolean;
         toRdfTypes: readonly NamedNode[];
         tsFeatures: ReadonlySet<TsFeature>;
         tsImports: readonly string[];
         tsObjectDeclarationType: TsObjectDeclarationType;
     } & ConstructorParameters<typeof AbstractType>[0]);
-    addAncestorObjectTypes(...ancestorObjectTypes: readonly ObjectType[]): void;
-    addChildObjectTypes(...childObjectTypes: readonly ObjectType[]): void;
-    addDescendantObjectTypes(...descendantObjectTypes: readonly ObjectType[]): void;
-    addParentObjectTypes(...parentObjectTypes: readonly ObjectType[]): void;
-    addProperties(...properties: readonly ObjectType.Property[]): void;
     get ancestorObjectTypes(): readonly ObjectType[];
     get childObjectTypes(): readonly ObjectType[];
     get descendantObjectTypes(): readonly ObjectType[];
     get parentObjectTypes(): readonly ObjectType[];
     get properties(): readonly ObjectType.Property[];
+    get recursive(): boolean;
+    addAncestorObjectTypes(...ancestorObjectTypes: readonly ObjectType[]): void;
+    addChildObjectTypes(...childObjectTypes: readonly ObjectType[]): void;
+    addDescendantObjectTypes(...descendantObjectTypes: readonly ObjectType[]): void;
+    addParentObjectTypes(...parentObjectTypes: readonly ObjectType[]): void;
+    addProperties(...properties: readonly ObjectType.Property[]): void;
     equals(other: ObjectType): boolean;
     sortProperties(): void;
     toString(): string;
@@ -135,13 +118,13 @@ export declare namespace ObjectType {
          */
         readonly mutable: boolean;
         /**
-         * Object type this property belongs to.
+         * Name of this property, derived from sh:name or shaclmate:name.
          */
-        readonly objectType: ObjectType;
+        readonly name: string;
         /**
-         * Name of this property, derived from sh:name or shaclmate:name.
+         * Object type this property belongs to.
          */
-        readonly name: Maybe<string>;
+        readonly objectType: ObjectType;
         /**
          * Relative order of this property, derived from sh:order.
          */
@@ -149,7 +132,7 @@ export declare namespace ObjectType {
         /**
          * SHACL property path (https://www.w3.org/TR/shacl/#property-paths)
          */
-        readonly path: Curie | PropertyPath;
+        readonly path: PropertyPath;
         /**
          * Identifier of the property shape.
          */
@@ -167,10 +150,10 @@ export declare namespace ObjectType {
             description: Maybe<string>;
             label: Maybe<string>;
             mutable: boolean;
-            name: Maybe<string>;
+            name: string;
             objectType: ObjectType;
             order: number;
-            path: Curie | PropertyPath;
+            path: PropertyPath;
             shapeIdentifier: BlankNode | NamedNode;
             type: Type;
             visibility: PropertyVisibility;