@shaclmate/compiler 4.0.40 → 4.0.42

package/dist/ast/{AbstractLazyObjectType.d.ts → AbstractLazyType.d.ts}

@@ -1,14 +1,14 @@
 import type { NodeKind } from "@shaclmate/shacl-ast";
 import { AbstractType } from "./AbstractType.js";
-import type { ObjectType } from "./ObjectType.js";
-import type { ObjectUnionType } from "./ObjectUnionType.js";
 import type { OptionType } from "./OptionType.js";
 import type { SetType } from "./SetType.js";
+import type { StructType } from "./StructType.js";
+import type { StructUnionType } from "./StructUnionType.js";
 /**
- * Abstract base class of LazyObjectOptionType, LazyObjectSetType, and LazyObjectType.
+ * Abstract base class of LazyOptionType, LazySetType, and LazyType.
  */
-export declare abstract class AbstractLazyObjectType<PartialTypeT extends AbstractLazyObjectType.PartialTypeConstraint, ResolveTypeT extends AbstractLazyObjectType.ResolveTypeConstraint> extends AbstractType {
-    abstract readonly kind: "LazyObjectOption" | "LazyObjectSet" | "LazyObject";
+export declare abstract class AbstractLazyType<PartialTypeT extends AbstractLazyType.PartialTypeConstraint, ResolveTypeT extends AbstractLazyType.ResolveTypeConstraint> extends AbstractType {
+    abstract readonly kind: "Lazy" | "LazyOption" | "LazySet";
     readonly partialType: PartialTypeT;
     readonly resolveType: ResolveTypeT;
     constructor({ partialType, resolveType, ...superParameters }: {
@@ -17,7 +17,7 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
     } & ConstructorParameters<typeof AbstractType>[0]);
     get nodeKinds(): ReadonlySet<NodeKind>;
     get recursive(): boolean;
-    equals(other: AbstractLazyObjectType<PartialTypeT, ResolveTypeT>): boolean;
+    equals(other: AbstractLazyType<PartialTypeT, ResolveTypeT>): boolean;
     toJSON(): {
         partialType: {
             fromRdfType: import("@rdfjs/types").NamedNode<string> | undefined;
@@ -32,7 +32,6 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
                 recursive: boolean | undefined;
                 shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
             };
-            parentObjectTypes: (string | import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>)[] | undefined;
             synthetic: boolean | undefined;
             toRdfTypes: readonly import("@rdfjs/types").NamedNode<string>[] | undefined;
             comment: string | undefined;
@@ -74,7 +73,6 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
                 recursive: boolean | undefined;
                 shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
             };
-            parentObjectTypes: (string | import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>)[] | undefined;
             synthetic: boolean | undefined;
             toRdfTypes: readonly import("@rdfjs/types").NamedNode<string>[] | undefined;
             comment: string | undefined;
@@ -111,9 +109,9 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
         shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
     };
 }
-export declare namespace AbstractLazyObjectType {
-    type ObjectTypeConstraint = ObjectType | ObjectUnionType;
-    type PartialTypeConstraint = ObjectTypeConstraint | OptionType<ObjectTypeConstraint> | SetType<ObjectTypeConstraint>;
+export declare namespace AbstractLazyType {
+    type ItemTypeConstraint = StructType | StructUnionType;
+    type PartialTypeConstraint = ItemTypeConstraint | OptionType<ItemTypeConstraint> | SetType<ItemTypeConstraint>;
     type ResolveTypeConstraint = PartialTypeConstraint;
 }
-//# sourceMappingURL=AbstractLazyObjectType.d.ts.map
+//# sourceMappingURL=AbstractLazyType.d.ts.map

package/dist/ast/{AbstractLazyObjectType.js → AbstractLazyType.js}

@@ -1,9 +1,9 @@
 import { AbstractType } from "./AbstractType.js";
 import { Type } from "./Type.js";
 /**
- * Abstract base class of LazyObjectOptionType, LazyObjectSetType, and LazyObjectType.
+ * Abstract base class of LazyOptionType, LazySetType, and LazyType.
  */
-export class AbstractLazyObjectType extends AbstractType {
+export class AbstractLazyType extends AbstractType {
     partialType;
     resolveType;
     constructor({ partialType, resolveType, ...superParameters }) {
@@ -37,4 +37,4 @@ export class AbstractLazyObjectType extends AbstractType {
         };
     }
 }
-//# sourceMappingURL=AbstractLazyObjectType.js.map
+//# sourceMappingURL=AbstractLazyType.js.map

package/dist/ast/AbstractType.d.ts

@@ -24,7 +24,7 @@ export declare abstract class AbstractType {
     /**
      * The range of node kinds of this type.
      *
-     * For example, an object type has blank and IRI node kinds, while a string type has a Literal node kind.
+     * For example, a struct type has blank and IRI node kinds, while a string type has a Literal node kind.
      */
     abstract readonly nodeKinds: ReadonlySet<NodeKind>;
     /**

package/dist/ast/AbstractType.js

@@ -33,6 +33,9 @@ export class AbstractType {
         if (!maybeEquals(strictEquals)(this.label, other.label)) {
             return false;
         }
+        if (!maybeEquals(strictEquals)(this.name, other.name)) {
+            return false;
+        }
         return true;
     }
     toJSON() {

package/dist/ast/Ast.d.ts

@@ -1,10 +1,6 @@
-import type { IntersectionType } from "./IntersectionType.js";
-import type { ObjectType } from "./ObjectType.js";
-import type { UnionType } from "./UnionType.js";
+import type { Type } from "./Type.js";
 export interface Ast {
     readonly lazyTypesCount: number;
-    readonly namedIntersectionTypes: readonly IntersectionType[];
-    readonly namedObjectTypes: readonly ObjectType[];
-    readonly namedUnionTypes: readonly UnionType[];
+    readonly namedTypes: readonly Type[];
 }
 //# sourceMappingURL=Ast.d.ts.map

package/dist/ast/DefaultValueType.js

@@ -1,3 +1,4 @@
+import { Maybe } from "purify-ts";
 import { AbstractContainerType } from "./AbstractContainerType.js";
 import { termEquals } from "./equals.js";
 /**
@@ -16,7 +17,7 @@ export class DefaultValueType extends AbstractContainerType {
             comment: itemType.comment,
             itemType,
             label: itemType.label,
-            name: itemType.name,
+            name: Maybe.empty(),
             shapeIdentifier: itemType.shapeIdentifier,
         });
         this.defaultValue = defaultValue;

package/dist/ast/IntersectionType.d.ts

@@ -1,11 +1,11 @@
 import { AbstractCompoundType } from "./AbstractCompoundType.js";
-import type { ObjectIntersectionType } from "./ObjectIntersectionType.js";
+import type { StructIntersectionType } from "./StructIntersectionType.js";
 /**
  * A conjunction ("and") of types, corresponding to an sh:and.
  */
 export declare class IntersectionType<MemberTypeT extends IntersectionType.MemberType = IntersectionType.MemberType> extends AbstractCompoundType<AbstractCompoundType.Member<MemberTypeT>, MemberTypeT> {
     readonly kind = "Intersection";
-    isObjectIntersectionType(): this is ObjectIntersectionType;
+    isStructIntersectionType(): this is StructIntersectionType;
 }
 export declare namespace IntersectionType {
     type MemberType = AbstractCompoundType.MemberType;

package/dist/ast/IntersectionType.js

@@ -4,11 +4,11 @@ import { AbstractCompoundType } from "./AbstractCompoundType.js";
  */
 export class IntersectionType extends AbstractCompoundType {
     kind = "Intersection";
-    isObjectIntersectionType() {
+    isStructIntersectionType() {
         return (this.members.length > 0 &&
-            this.members.every((member) => member.type.kind === "Object" ||
+            this.members.every((member) => member.type.kind === "Struct" ||
                 (member.type.kind === "Intersection" &&
-                    member.type.isObjectIntersectionType())));
+                    member.type.isStructIntersectionType())));
     }
 }
 (function (IntersectionType) {

package/dist/ast/LazyOptionType.d.ts

@@ -0,0 +1,6 @@
+import { AbstractLazyType } from "./AbstractLazyType.js";
+import type { OptionType } from "./OptionType.js";
+export declare class LazyOptionType extends AbstractLazyType<OptionType<AbstractLazyType.ItemTypeConstraint>, OptionType<AbstractLazyType.ItemTypeConstraint>> {
+    readonly kind = "LazyOption";
+}
+//# sourceMappingURL=LazyOptionType.d.ts.map

package/dist/ast/LazyOptionType.js

@@ -0,0 +1,5 @@
+import { AbstractLazyType } from "./AbstractLazyType.js";
+export class LazyOptionType extends AbstractLazyType {
+    kind = "LazyOption";
+}
+//# sourceMappingURL=LazyOptionType.js.map

package/dist/ast/LazySetType.d.ts

@@ -0,0 +1,6 @@
+import { AbstractLazyType } from "./AbstractLazyType.js";
+import type { SetType } from "./SetType.js";
+export declare class LazySetType extends AbstractLazyType<SetType<AbstractLazyType.ItemTypeConstraint>, SetType<AbstractLazyType.ItemTypeConstraint>> {
+    readonly kind = "LazySet";
+}
+//# sourceMappingURL=LazySetType.d.ts.map

package/dist/ast/LazySetType.js

@@ -0,0 +1,5 @@
+import { AbstractLazyType } from "./AbstractLazyType.js";
+export class LazySetType extends AbstractLazyType {
+    kind = "LazySet";
+}
+//# sourceMappingURL=LazySetType.js.map

package/dist/ast/LazyType.d.ts

@@ -0,0 +1,5 @@
+import { AbstractLazyType } from "./AbstractLazyType.js";
+export declare class LazyType extends AbstractLazyType<AbstractLazyType.ItemTypeConstraint, AbstractLazyType.ItemTypeConstraint> {
+    readonly kind = "Lazy";
+}
+//# sourceMappingURL=LazyType.d.ts.map

package/dist/ast/LazyType.js

@@ -0,0 +1,5 @@
+import { AbstractLazyType } from "./AbstractLazyType.js";
+export class LazyType extends AbstractLazyType {
+    kind = "Lazy";
+}
+//# sourceMappingURL=LazyType.js.map

package/dist/ast/ListType.d.ts

@@ -6,7 +6,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 { ObjectType } from "./ObjectType.js";
+import type { StructType } from "./StructType.js";
 import type { TermType } from "./TermType.js";
 import type { Type } from "./Type.js";
 import type { UnionType } from "./UnionType.js";
@@ -38,7 +38,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 | ObjectType | TermType | UnionType;
+    type ItemType = BlankNodeType | IdentifierType | IntersectionType | IriType | ListType | LiteralType | StructType | TermType | UnionType;
     function isItemType(type: Type): type is ItemType;
 }
 //# sourceMappingURL=ListType.d.ts.map

package/dist/ast/ListType.js

@@ -36,16 +36,16 @@ export class ListType extends AbstractCollectionType {
             case "Identifier":
             case "Intersection":
             case "Iri":
+            case "List":
             case "Literal":
-            case "Object":
+            case "Struct":
             case "Term":
             case "Union":
                 return true;
             case "DefaultValue":
-            case "LazyObjectOption":
-            case "LazyObjectSet":
-            case "LazyObject":
-            case "List":
+            case "LazyOption":
+            case "LazySet":
+            case "Lazy":
             case "Option":
             case "Set":
                 return false;

package/dist/ast/OptionType.js

@@ -1,3 +1,4 @@
+import { Maybe } from "purify-ts";
 import { AbstractContainerType } from "./AbstractContainerType.js";
 /**
  * A type with zero or one values of an item type.
@@ -9,7 +10,7 @@ export class OptionType extends AbstractContainerType {
             comment: itemType.comment,
             itemType,
             label: itemType.label,
-            name: itemType.name,
+            name: Maybe.empty(),
             shapeIdentifier: itemType.shapeIdentifier,
         });
     }

package/dist/ast/SetType.js

@@ -1,3 +1,4 @@
+import { Maybe } from "purify-ts";
 import { AbstractCollectionType } from "./AbstractCollectionType.js";
 /**
  * An unordered set of items of a specific type.
@@ -14,7 +15,7 @@ export class SetType extends AbstractCollectionType {
             comment: itemType.comment,
             itemType,
             label: itemType.label,
-            name: itemType.name,
+            name: Maybe.empty(),
             shapeIdentifier: itemType.shapeIdentifier,
         });
         this.minCount = minCount;

package/dist/ast/StructCompoundType.d.ts

@@ -0,0 +1,12 @@
+import { BlankNodeType } from "./BlankNodeType.js";
+import { IdentifierType } from "./IdentifierType.js";
+import { IriType } from "./IriType.js";
+import type { StructIntersectionType } from "./StructIntersectionType.js";
+import type { StructType } from "./StructType.js";
+import type { StructUnionType } from "./StructUnionType.js";
+export type StructCompoundType = StructIntersectionType | StructUnionType;
+export declare namespace StructCompoundType {
+    function identifierType(objectCompoundType: StructCompoundType): BlankNodeType | IdentifierType | IriType;
+    function memberStructTypes(objectCompoundType: StructCompoundType): readonly StructType[];
+}
+//# sourceMappingURL=StructCompoundType.d.ts.map

package/dist/ast/{ObjectCompoundType.js → StructCompoundType.js}

@@ -4,12 +4,12 @@ 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) {
+export var StructCompoundType;
+(function (StructCompoundType) {
     function identifierType(objectCompoundType) {
         const memberIdentifierTypeNodeKinds = new Set();
         const memberIdentifierTypesIn = new TermSet();
-        for (const memberType of memberObjectTypes(objectCompoundType)) {
+        for (const memberType of memberStructTypes(objectCompoundType)) {
             for (const nodeKind of memberType.identifierType.nodeKinds) {
                 memberIdentifierTypeNodeKinds.add(nodeKind);
             }
@@ -49,39 +49,39 @@ export var ObjectCompoundType;
                 throw new Error("should never reach here");
         }
     }
-    ObjectCompoundType.identifierType = identifierType;
-    function memberObjectTypes(objectCompoundType) {
-        const memberObjectTypes_ = [];
+    StructCompoundType.identifierType = identifierType;
+    function memberStructTypes(objectCompoundType) {
+        const memberStructTypes_ = [];
         for (const member of objectCompoundType.members) {
             switch (member.type.kind) {
-                case "Object":
-                    memberObjectTypes_.push(member.type);
+                case "Struct":
+                    memberStructTypes_.push(member.type);
                     break;
                 case "Intersection":
                 case "Union": {
                     invariant(member.type.kind === objectCompoundType.kind);
-                    memberObjectTypes_.push(...memberObjectTypes(member.type));
+                    memberStructTypes_.push(...memberStructTypes(member.type));
                     break;
                 }
             }
         }
-        invariant(memberObjectTypes_.length >= objectCompoundType.members.length, "object compound type has no member ObjectType's");
+        invariant(memberStructTypes_.length >= objectCompoundType.members.length, "object compound type has no member StructType'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) {
+        for (const memberStructType of memberStructTypes_) {
+            if (memberStructType.extern) {
                 continue;
             }
             expectUniqueFromRdfTypesCount++;
-            memberObjectType.fromRdfType.ifJust((fromRdfType) => fromRdfTypes.add(fromRdfType));
+            memberStructType.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].join(", ")}})`);
+            throw new Error(`one or more ${objectCompoundType} members ([${memberStructTypes_.map((memberType) => memberType.toString()).join(", ")}]) lack distinguishing fromRdfType's ({${[...fromRdfTypes].join(", ")}})`);
         }
-        return memberObjectTypes_;
+        return memberStructTypes_;
     }
-    ObjectCompoundType.memberObjectTypes = memberObjectTypes;
-})(ObjectCompoundType || (ObjectCompoundType = {}));
-//# sourceMappingURL=ObjectCompoundType.js.map
+    StructCompoundType.memberStructTypes = memberStructTypes;
+})(StructCompoundType || (StructCompoundType = {}));
+//# sourceMappingURL=StructCompoundType.js.map

package/dist/ast/StructIntersectionType.d.ts

@@ -0,0 +1,4 @@
+import type { IntersectionType } from "./IntersectionType.js";
+import type { StructType } from "./StructType.js";
+export type StructIntersectionType = IntersectionType<IntersectionType<StructType> | StructType>;
+//# sourceMappingURL=StructIntersectionType.d.ts.map

package/dist/ast/StructIntersectionType.js

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

package/dist/ast/{ObjectType.d.ts → StructType.d.ts}

@@ -7,16 +7,17 @@ import type { BlankNodeType } from "./BlankNodeType.js";
 import type { IdentifierType } from "./IdentifierType.js";
 import type { IriType } from "./IriType.js";
 import { Type } from "./Type.js";
-export declare class ObjectType extends AbstractType {
+export declare class StructType extends AbstractType {
     #private;
+    private fieldNames;
     /**
-     * If true, the code for this ObjectType is defined externally and should not be generated.
+     * If true, the code for this StructType is defined externally and should not be generated.
      *
      * Defaults to false.
      */
     readonly extern: boolean;
     /**
-     * The expected rdf:type of instances of this ObjectType.
+     * The expected rdf:type of instances of this StructType.
      *
      * This is usually the identifier of an sh:NodeShape that is also an rdfs:Class (i.e., a node shape with implicit
      * class targets).
@@ -29,7 +30,7 @@ export declare class ObjectType extends AbstractType {
     /**
      * Type discriminant.
      */
-    readonly kind = "Object";
+    readonly kind = "Struct";
     readonly nodeKinds: ReadonlySet<NodeKind>;
     /**
      * Was this type synthesized or did it come from SHACL?
@@ -45,7 +46,7 @@ export declare class ObjectType extends AbstractType {
     /**
      * TypeScript imports to add to generated code.
      *
-     * This is often used in conjunction with extern=true to import the extern'd ObjectType code in order for generated
+     * This is often used in conjunction with extern=true to import the extern'd StructType code in order for generated
      * code to reference it.
      *
      * import { MyType } from "./MyType.js"
@@ -59,19 +60,11 @@ export declare class ObjectType extends AbstractType {
         toRdfTypes: readonly NamedNode[];
         tsImports: readonly string[];
     } & ConstructorParameters<typeof AbstractType>[0]);
-    get ancestorObjectTypes(): readonly ObjectType[];
-    get childObjectTypes(): readonly ObjectType[];
-    get descendantObjectTypes(): readonly ObjectType[];
-    get parentObjectTypes(): readonly ObjectType[];
-    get properties(): readonly ObjectType.Property[];
+    get fields(): readonly StructType.Field[];
     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;
+    addFields(...fields: readonly StructType.Field[]): void;
+    equals(other: StructType): boolean;
+    sortFields(): void;
     toJSON(): {
         fromRdfType: NamedNode<string> | undefined;
         identifierType: {
@@ -85,7 +78,6 @@ export declare class ObjectType extends AbstractType {
             recursive: boolean | undefined;
             shapeIdentifier: BlankNode | NamedNode<string>;
         };
-        parentObjectTypes: (string | BlankNode | NamedNode<string>)[] | undefined;
         synthetic: boolean | undefined;
         toRdfTypes: readonly NamedNode<string>[] | undefined;
         comment: string | undefined;
@@ -96,8 +88,8 @@ export declare class ObjectType extends AbstractType {
         shapeIdentifier: BlankNode | NamedNode<string>;
     };
 }
-export declare namespace ObjectType {
-    class Property {
+export declare namespace StructType {
+    class Field {
         /**
          * Documentation comment from rdfs:comment.
          */
@@ -107,7 +99,7 @@ export declare namespace ObjectType {
          */
         readonly description: Maybe<string>;
         /**
-         * Should the property and its value be displayed in a toString()-type representation?
+         * Should the field and its value be displayed in a toString()-type representation?
          */
         readonly display: boolean;
         /**
@@ -115,50 +107,50 @@ export declare namespace ObjectType {
          */
         readonly label: Maybe<string>;
         /**
-         * The property should be mutable in generated code i.e., it should be re-assignable. The property value may or may
+         * The field should be mutable in generated code i.e., it should be re-assignable. The field value may or may
          * not be mutable.
          */
         readonly mutable: boolean;
         /**
-         * Name of this property, derived from sh:name or shaclmate:name.
+         * Name of this field, derived from sh:name or shaclmate:name.
          */
         readonly name: string;
         /**
-         * Object type this property belongs to.
-         */
-        readonly objectType: ObjectType;
-        /**
-         * Relative order of this property, derived from sh:order.
+         * Relative order of this field, derived from sh:order.
          */
         readonly order: number;
         /**
-         * SHACL property path (https://www.w3.org/TR/shacl/#property-paths)
+         * SHACL property path (https://www.w3.org/TR/shacl/#field-paths)
          */
         readonly path: PropertyPath;
         /**
-         * Identifier of the property shape.
+         * Identifier of the field shape.
          */
         readonly shapeIdentifier: BlankNode | NamedNode;
         /**
-         * Type of this property.
+         * StructType this field belongs to.
+         */
+        readonly structType: StructType;
+        /**
+         * Type of this field.
          */
         readonly type: Type;
-        constructor({ comment, description, display, label, mutable, name, objectType, order, path, shapeIdentifier, type, }: {
+        constructor({ comment, description, display, label, mutable, name, order, path, shapeIdentifier, structType, type, }: {
             comment: Maybe<string>;
             description: Maybe<string>;
             display: boolean;
             label: Maybe<string>;
             mutable: boolean;
             name: string;
-            objectType: ObjectType;
             order: number;
             path: PropertyPath;
             shapeIdentifier: BlankNode | NamedNode;
+            structType: StructType;
             type: Type;
         });
-        equals(other: Property): boolean;
+        equals(other: Field): boolean;
         /**
-         * Does the property directly or indirectly reference the ObjectType itself?
+         * Does the field directly or indirectly reference the StructType itself?
          */
         get recursive(): boolean;
         toJSON(): {
@@ -183,7 +175,4 @@ export declare namespace ObjectType {
         toString(): string;
     }
 }
-export declare namespace ObjectType {
-    function toposort(objectTypes: readonly ObjectType[]): readonly ObjectType[];
-}
-//# sourceMappingURL=ObjectType.d.ts.map
+//# sourceMappingURL=StructType.d.ts.map