@shaclmate/compiler 4.0.38 → 4.0.39

package/dist/ShapesGraphToAstTransformer.js

@@ -103,24 +103,24 @@ export class ShapesGraphToAstTransformer {
             }
             const nodeShapeAstType = nodeShapeAstTypeEither.unsafeCoerce();
             switch (nodeShapeAstType.kind) {
-                case "IntersectionType":
+                case "Intersection":
                     if (nodeShapeAstType.name.isJust()) {
                         astNamedIntersectionTypes.push(nodeShapeAstType);
                     }
                     break;
-                case "ObjectType": {
+                case "Object": {
                     invariant(nodeShapeAstType.name.isJust(), `node shape missing name: ${nodeShapeAstType.shapeIdentifier}`);
                     astObjectTypes.push(nodeShapeAstType);
                     for (const property of nodeShapeAstType.properties) {
                         switch (property.type.kind) {
-                            case "LazyObjectOptionType":
-                            case "LazyObjectSetType":
-                            case "LazyObjectType": {
-                                const partialItemType = property.type.partialType.kind === "ObjectType" ||
-                                    property.type.partialType.kind === "UnionType"
+                            case "LazyObjectOption":
+                            case "LazyObjectSet":
+                            case "LazyObject": {
+                                const partialItemType = property.type.partialType.kind === "Object" ||
+                                    property.type.partialType.kind === "Union"
                                     ? property.type.partialType
                                     : property.type.partialType.itemType;
-                                if (partialItemType.kind === "ObjectType" &&
+                                if (partialItemType.kind === "Object" &&
                                     partialItemType.synthetic) {
                                     const partialItemTypeName = partialItemType.name.unsafeCoerce();
                                     if (!syntheticAstObjectTypesByName[partialItemTypeName]) {
@@ -133,7 +133,7 @@ export class ShapesGraphToAstTransformer {
                     }
                     break;
                 }
-                case "UnionType":
+                case "Union":
                     if (nodeShapeAstType.name.isJust()) {
                         astNamedUnionTypes.push(nodeShapeAstType);
                     }
@@ -145,9 +145,9 @@ export class ShapesGraphToAstTransformer {
         return Either.of({
             lazyTypesCount: [...this.cachedAstTypesByShapeIdentifier.values()].reduce((acc, astType) => {
                 switch (astType.kind) {
-                    case "LazyObjectType":
-                    case "LazyObjectOptionType":
-                    case "LazyObjectSetType":
+                    case "LazyObject":
+                    case "LazyObjectOption":
+                    case "LazyObjectSet":
                         return acc + 1;
                     default:
                         return acc;

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstObjectTypeProperty.js

@@ -9,12 +9,12 @@ import { transformShapeToAstType } from "./transformShapeToAstType.js";
 function synthesizePartialAstObjectType({ identifierType, }) {
     let syntheticName;
     switch (identifierType.kind) {
-        case "BlankNodeType":
+        case "BlankNode":
             throw new Error("should never happen");
-        case "IdentifierType":
+        case "Identifier":
             syntheticName = "DefaultPartial";
             break;
-        case "IriType":
+        case "Iri":
             syntheticName = "NamedDefaultPartial";
             break;
     }
@@ -92,7 +92,7 @@ function transformPropertyShapeToAstType(propertyShape, shapeStack) {
         if (maxCount < minCount) {
             maxCount = minCount;
         }
-        if (propertyShapeAstType.kind === "DefaultValueType") {
+        if (propertyShapeAstType.kind === "DefaultValue") {
             if (minCount > 0n) {
                 return Left(new Error(`${propertyShape}: has sh:minCount > 0 and sh:defaultValue`));
             }
@@ -135,9 +135,9 @@ export function transformPropertyShapeToAstObjectTypeProperty({ objectType, prop
                 .call(this, propertyShapeResolve.unsafeCoerce(), shapeStack)
                 .chain((astResolveType) => {
                 switch (astResolveType.kind) {
-                    case "ObjectType":
+                    case "Object":
                         return Either.of(astResolveType);
-                    case "UnionType":
+                    case "Union":
                         if (
                         // This check relies on .members being populated, which may not happen in cycles
                         astResolveType.members.length > 0 &&
@@ -157,15 +157,15 @@ export function transformPropertyShapeToAstObjectTypeProperty({ objectType, prop
         if (astResolveItemType) {
             let astItemType;
             switch (astType.kind) {
-                case "DefaultValueType":
-                case "OptionType":
-                case "SetType":
+                case "DefaultValue":
+                case "Option":
+                case "Set":
                     astItemType = astType.itemType;
                     break;
-                case "LazyObjectOptionType":
-                case "LazyObjectSetType":
+                case "LazyObjectOption":
+                case "LazyObjectSet":
                 // biome-ignore lint/suspicious/noFallthroughSwitchClause: break is unreachable
-                case "LazyObjectType":
+                case "LazyObject":
                     invariant(false, `lazy types should not appear here: ${astType.kind}`);
                 default:
                     astItemType = astType;
@@ -173,17 +173,17 @@ export function transformPropertyShapeToAstObjectTypeProperty({ objectType, prop
             }
             let astPartialItemType;
             switch (astItemType.kind) {
-                case "BlankNodeType":
-                case "IdentifierType":
-                case "IriType":
+                case "BlankNode":
+                case "Identifier":
+                case "Iri":
                     astPartialItemType = synthesizePartialAstObjectType({
                         identifierType: astItemType,
                     });
                     break;
-                case "ObjectType":
+                case "Object":
                     astPartialItemType = astItemType;
                     break;
-                case "UnionType":
+                case "Union":
                     if (!astItemType.isObjectUnionType()) {
                         return Left(new Error(`${propertyShape} partial type cannot be a ${astItemType.kind} with non-ObjectType members`));
                     }
@@ -199,18 +199,18 @@ export function transformPropertyShapeToAstObjectTypeProperty({ objectType, prop
                 shapeIdentifier: propertyShape.$identifier(),
             };
             switch (astType.kind) {
-                case "BlankNodeType":
-                case "IdentifierType":
-                case "IriType":
-                case "ObjectType":
-                case "UnionType":
+                case "BlankNode":
+                case "Identifier":
+                case "Iri":
+                case "Object":
+                case "Union":
                     astType = new ast.LazyObjectType({
                         ...astAbstractTypeProperties,
                         partialType: astPartialItemType,
                         resolveType: astResolveItemType,
                     });
                     break;
-                case "OptionType":
+                case "Option":
                     astType = new ast.LazyObjectOptionType({
                         ...astAbstractTypeProperties,
                         partialType: new ast.OptionType({
@@ -221,7 +221,7 @@ export function transformPropertyShapeToAstObjectTypeProperty({ objectType, prop
                         }),
                     });
                     break;
-                case "SetType":
+                case "Set":
                     astType = new ast.LazyObjectSetType({
                         ...astAbstractTypeProperties,
                         partialType: new ast.SetType({

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstCompoundType.js

@@ -21,18 +21,18 @@ export function transformShapeToAstCompoundType(shape, shapeStack) {
             let memberShapes;
             if (andConstraintShapes.length > 0) {
                 memberShapes = andConstraintShapes;
-                compoundTypeKind = "IntersectionType";
+                compoundTypeKind = "Intersection";
             }
             else if (xoneConstraintShapes.length > 0) {
                 memberShapes = xoneConstraintShapes;
-                compoundTypeKind = "UnionType";
+                compoundTypeKind = "Union";
             }
             else {
                 return Either.of(Maybe.empty());
             }
             invariant(memberShapes.length > 0);
             const memberDiscriminantValues = new Set();
-            const compoundType = new (compoundTypeKind === "IntersectionType"
+            const compoundType = new (compoundTypeKind === "Intersection"
                 ? ast.IntersectionType
                 : ast.UnionType)({
                 comment: shape.comment,
@@ -61,7 +61,7 @@ export function transformShapeToAstCompoundType(shape, shapeStack) {
                         return Left(new Error(`${shape} has duplicate ${compoundTypeKind} member type: ${memberType}`));
                     }
                     let memberDiscriminantValue;
-                    if (compoundTypeKind === "UnionType") {
+                    if (compoundTypeKind === "Union") {
                         if (memberShape.$type === "NodeShape") {
                             memberDiscriminantValue =
                                 memberShape.discriminantValue.extract();

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstListType.js

@@ -120,7 +120,7 @@ export function transformShapeToAstListType(shape, shapeStack) {
                             propertyShape: restPropertyShape,
                         })
                             .chain((restProperty) => {
-                            if (restProperty.type.kind !== "ListType" ||
+                            if (restProperty.type.kind !== "List" ||
                                 !restProperty.type.shapeIdentifier.equals(nodeShape.$identifier())) {
                                 return Left(new Error(`${nodeShape} rdf:rest property is not recursive into the node shape`));
                             }

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstObjectType.js

@@ -11,28 +11,28 @@ import { transformPropertyShapeToAstObjectTypeProperty } from "./transformProper
 import { transformShapeToAstType } from "./transformShapeToAstType.js";
 function isObjectTypePropertyRequired(property) {
     switch (property.type.kind) {
-        case "DefaultValueType":
+        case "DefaultValue":
             return false;
-        case "LazyObjectOptionType":
+        case "LazyObjectOption":
             return false;
-        case "LazyObjectSetType":
+        case "LazyObjectSet":
             return property.type.partialType.minCount > 0n;
-        case "OptionType":
+        case "Option":
             return false;
-        case "SetType":
+        case "Set":
             return property.type.minCount > 0;
-        case "UnionType":
+        case "Union":
             return property.type.members.every((member) => isObjectTypePropertyRequired({ type: member.type }));
-        case "BlankNodeType":
-        case "IdentifierType":
-        case "IriType":
-        case "LazyObjectType":
-        case "ListType":
-        case "LiteralType":
-        case "ObjectType":
-        case "TermType":
+        case "BlankNode":
+        case "Identifier":
+        case "Iri":
+        case "LazyObject":
+        case "List":
+        case "Literal":
+        case "Object":
+        case "Term":
             return true;
-        case "IntersectionType":
+        case "Intersection":
             throw new Error("unsupported");
         default:
             property.type;
@@ -138,7 +138,7 @@ export function transformShapeToAstObjectType(shape, shapeStack) {
                         .call(this, relatedNodeShape, new ShapeStack())
                         .toMaybe()
                         .toList())
-                        .filter((astType) => astType.kind === "ObjectType");
+                        .filter((astType) => astType.kind === "Object");
                 };
                 objectType.addAncestorObjectTypes(...relatedObjectTypes(ancestorNodeShapes));
                 objectType.addChildObjectTypes(...relatedObjectTypes(childNodeShapes));

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstTermType.js

@@ -76,7 +76,7 @@ export function transformShapeToAstTermType(shape, shapeStack) {
             return shapeStack.defaultValue
                 .map((defaultValue) => {
                 switch (termType.kind) {
-                    case "BlankNodeType":
+                    case "BlankNode":
                         return Left(new Error(`${shape}: blank node identifier types cannot have default values`));
                 }
                 switch (termType.hasValues.length) {

package/dist/ast/AbstractCollectionType.d.ts

@@ -3,7 +3,7 @@ import { AbstractContainerType } from "./AbstractContainerType.js";
  * Abstract base class for a collection of items of a single type. This is the parent of ListType and SetType.
  */
 export declare abstract class AbstractCollectionType<ItemTypeT extends AbstractCollectionType.ItemType = AbstractCollectionType.ItemType> extends AbstractContainerType<ItemTypeT> {
-    abstract readonly kind: "ListType" | "SetType";
+    abstract readonly kind: "List" | "Set";
     /**
      * The collection should be mutable in generated code.
      */

package/dist/ast/AbstractCompoundType.d.ts

@@ -20,7 +20,7 @@ export declare abstract class AbstractCompoundType<MemberT extends AbstractCompo
     /**
      * Type discriminant
      */
-    abstract readonly kind: "IntersectionType" | "UnionType";
+    abstract readonly kind: "Intersection" | "Union";
     /**
      * Was this type synthesized or did it come from SHACL?
      */

package/dist/ast/AbstractCompoundType.js

@@ -57,22 +57,22 @@ __decorate([
 (function (AbstractCompoundType) {
     function isMemberType(type) {
         switch (type.kind) {
-            case "BlankNodeType":
-            case "IdentifierType":
-            case "IntersectionType":
-            case "IriType":
-            case "LiteralType":
-            case "ObjectType":
-            case "TermType":
-            case "UnionType":
+            case "BlankNode":
+            case "Identifier":
+            case "Intersection":
+            case "Iri":
+            case "Literal":
+            case "Object":
+            case "Term":
+            case "Union":
                 return true;
-            case "DefaultValueType":
-            case "LazyObjectOptionType":
-            case "LazyObjectSetType":
-            case "LazyObjectType":
-            case "ListType":
-            case "OptionType":
-            case "SetType":
+            case "DefaultValue":
+            case "LazyObjectOption":
+            case "LazyObjectSet":
+            case "LazyObject":
+            case "List":
+            case "Option":
+            case "Set":
                 return false;
         }
     }

package/dist/ast/AbstractContainerType.d.ts

@@ -14,7 +14,7 @@ import type { UnionType } from "./UnionType.js";
  * Abstract base class for types that contain other types e.g., ListType, OptionType, SetType.
  */
 export declare abstract class AbstractContainerType<ItemTypeT extends AbstractContainerType.ItemType = AbstractContainerType.ItemType> extends AbstractType {
-    abstract readonly kind: "DefaultValueType" | "ListType" | "OptionType" | "SetType";
+    abstract readonly kind: "DefaultValue" | "List" | "Option" | "Set";
     /**
      * Container item type.
      *

package/dist/ast/AbstractContainerType.js

@@ -39,22 +39,22 @@ export class AbstractContainerType extends AbstractType {
 (function (AbstractContainerType) {
     function isItemType(type) {
         switch (type.kind) {
-            case "BlankNodeType":
-            case "IdentifierType":
-            case "IntersectionType":
-            case "IriType":
-            case "ListType":
-            case "LiteralType":
-            case "ObjectType":
-            case "TermType":
-            case "UnionType":
+            case "BlankNode":
+            case "Identifier":
+            case "Intersection":
+            case "Iri":
+            case "List":
+            case "Literal":
+            case "Object":
+            case "Term":
+            case "Union":
                 return true;
-            case "DefaultValueType":
-            case "LazyObjectOptionType":
-            case "LazyObjectSetType":
-            case "LazyObjectType":
-            case "OptionType":
-            case "SetType":
+            case "DefaultValue":
+            case "LazyObjectOption":
+            case "LazyObjectSet":
+            case "LazyObject":
+            case "Option":
+            case "Set":
                 return false;
         }
     }

package/dist/ast/AbstractLazyObjectType.d.ts

@@ -8,7 +8,7 @@ import type { SetType } from "./SetType.js";
  * Abstract base class of LazyObjectOptionType, LazyObjectSetType, and LazyObjectType.
  */
 export declare abstract class AbstractLazyObjectType<PartialTypeT extends AbstractLazyObjectType.PartialTypeConstraint, ResolveTypeT extends AbstractLazyObjectType.ResolveTypeConstraint> extends AbstractType {
-    abstract readonly kind: "LazyObjectOptionType" | "LazyObjectSetType" | "LazyObjectType";
+    abstract readonly kind: "LazyObjectOption" | "LazyObjectSet" | "LazyObject";
     readonly partialType: PartialTypeT;
     readonly resolveType: ResolveTypeT;
     constructor({ partialType, resolveType, ...superParameters }: {

package/dist/ast/AbstractTermType.d.ts

@@ -11,7 +11,7 @@ import { AbstractType } from "./AbstractType.js";
 export declare abstract class AbstractTermType<ConstantTermT extends Literal | NamedNode = Literal | NamedNode, _RuntimeTermT extends BlankNode | Literal | NamedNode = BlankNode | Literal | NamedNode> extends AbstractType {
     readonly hasValues: readonly ConstantTermT[];
     readonly in_: readonly ConstantTermT[];
-    abstract readonly kind: "BlankNodeType" | "IdentifierType" | "IriType" | "LiteralType" | "TermType";
+    abstract readonly kind: "BlankNode" | "Identifier" | "Iri" | "Literal" | "Term";
     readonly recursive = false;
     constructor({ hasValues, in_, ...superParameters }: {
         hasValues: readonly ConstantTermT[];

package/dist/ast/BlankNodeType.d.ts

@@ -4,7 +4,7 @@ import { AbstractTermType } from "./AbstractTermType.js";
  * A type corresponding to sh:nodeKind sh:BlankNode.
  */
 export declare class BlankNodeType extends AbstractTermType<NamedNode, BlankNode> {
-    readonly kind = "BlankNodeType";
+    readonly kind = "BlankNode";
     readonly nodeKinds: ReadonlySet<"BlankNode">;
     constructor(superParameters: Omit<ConstructorParameters<typeof AbstractTermType<NamedNode, BlankNode>>[0], "hasValues" | "in_">);
 }

package/dist/ast/BlankNodeType.js

@@ -3,7 +3,7 @@ import { AbstractTermType } from "./AbstractTermType.js";
  * A type corresponding to sh:nodeKind sh:BlankNode.
  */
 export class BlankNodeType extends AbstractTermType {
-    kind = "BlankNodeType";
+    kind = "BlankNode";
     nodeKinds = nodeKinds;
     constructor(superParameters) {
         super({

package/dist/ast/DefaultValueType.d.ts

@@ -12,7 +12,7 @@ import type { Type } from "./Type.js";
  */
 export declare class DefaultValueType<ItemTypeT extends DefaultValueType.ItemType = DefaultValueType.ItemType> extends AbstractContainerType<ItemTypeT> {
     readonly defaultValue: Literal | NamedNode;
-    readonly kind = "DefaultValueType";
+    readonly kind = "DefaultValue";
     constructor({ defaultValue, itemType, }: Pick<ConstructorParameters<typeof AbstractContainerType<ItemTypeT>>[0], "itemType"> & {
         defaultValue: Literal | NamedNode;
     });

package/dist/ast/DefaultValueType.js

@@ -10,7 +10,7 @@ import { termEquals } from "./equals.js";
  */
 export class DefaultValueType extends AbstractContainerType {
     defaultValue;
-    kind = "DefaultValueType";
+    kind = "DefaultValue";
     constructor({ defaultValue, itemType, }) {
         super({
             comment: itemType.comment,
@@ -39,7 +39,7 @@ export class DefaultValueType extends AbstractContainerType {
 }
 (function (DefaultValueType) {
     function isItemType(type) {
-        if (type.kind === "BlankNodeType") {
+        if (type.kind === "BlankNode") {
             return false;
         }
         return AbstractContainerType.isItemType(type);

package/dist/ast/IdentifierType.d.ts

@@ -5,7 +5,7 @@ import { AbstractTermType } from "./AbstractTermType.js";
  * A type corresponding to sh:nodeKind of a blank node or IRI, and not corresponding to a node shape.
  */
 export declare class IdentifierType extends AbstractTermType<NamedNode, BlankNode | NamedNode> {
-    readonly kind = "IdentifierType";
+    readonly kind = "Identifier";
     readonly nodeKinds: ReadonlySet<IdentifierNodeKind>;
     constructor(superParameters: Omit<ConstructorParameters<typeof AbstractTermType<NamedNode, BlankNode>>[0], "hasValues" | "in_">);
 }

package/dist/ast/IdentifierType.js

@@ -3,7 +3,7 @@ import { AbstractTermType } from "./AbstractTermType.js";
  * A type corresponding to sh:nodeKind of a blank node or IRI, and not corresponding to a node shape.
  */
 export class IdentifierType extends AbstractTermType {
-    kind = "IdentifierType";
+    kind = "Identifier";
     nodeKinds = nodeKinds;
     constructor(superParameters) {
         super({

package/dist/ast/IntersectionType.d.ts

@@ -4,7 +4,7 @@ import type { ObjectIntersectionType } from "./ObjectIntersectionType.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 = "IntersectionType";
+    readonly kind = "Intersection";
     isObjectIntersectionType(): this is ObjectIntersectionType;
 }
 export declare namespace IntersectionType {

package/dist/ast/IntersectionType.js

@@ -3,11 +3,11 @@ import { AbstractCompoundType } from "./AbstractCompoundType.js";
  * A conjunction ("and") of types, corresponding to an sh:and.
  */
 export class IntersectionType extends AbstractCompoundType {
-    kind = "IntersectionType";
+    kind = "Intersection";
     isObjectIntersectionType() {
         return (this.members.length > 0 &&
-            this.members.every((member) => member.type.kind === "ObjectType" ||
-                (member.type.kind === "IntersectionType" &&
+            this.members.every((member) => member.type.kind === "Object" ||
+                (member.type.kind === "Intersection" &&
                     member.type.isObjectIntersectionType())));
     }
 }

package/dist/ast/IriType.d.ts

@@ -4,7 +4,7 @@ import { AbstractTermType } from "./AbstractTermType.js";
  * A type corresponding to sh:nodeKind sh:IRI.
  */
 export declare class IriType extends AbstractTermType<NamedNode, NamedNode> {
-    readonly kind = "IriType";
+    readonly kind = "Iri";
     readonly nodeKinds: ReadonlySet<"IRI">;
 }
 //# sourceMappingURL=IriType.d.ts.map

package/dist/ast/IriType.js

@@ -3,7 +3,7 @@ import { AbstractTermType } from "./AbstractTermType.js";
  * A type corresponding to sh:nodeKind sh:IRI.
  */
 export class IriType extends AbstractTermType {
-    kind = "IriType";
+    kind = "Iri";
     nodeKinds = nodeKinds;
 }
 const nodeKinds = new Set(["IRI"]);

package/dist/ast/LazyObjectOptionType.d.ts

@@ -1,6 +1,6 @@
 import { AbstractLazyObjectType } from "./AbstractLazyObjectType.js";
 import type { OptionType } from "./OptionType.js";
 export declare class LazyObjectOptionType extends AbstractLazyObjectType<OptionType<AbstractLazyObjectType.ObjectTypeConstraint>, OptionType<AbstractLazyObjectType.ObjectTypeConstraint>> {
-    readonly kind = "LazyObjectOptionType";
+    readonly kind = "LazyObjectOption";
 }
 //# sourceMappingURL=LazyObjectOptionType.d.ts.map

package/dist/ast/LazyObjectOptionType.js

@@ -1,5 +1,5 @@
 import { AbstractLazyObjectType } from "./AbstractLazyObjectType.js";
 export class LazyObjectOptionType extends AbstractLazyObjectType {
-    kind = "LazyObjectOptionType";
+    kind = "LazyObjectOption";
 }
 //# sourceMappingURL=LazyObjectOptionType.js.map

package/dist/ast/LazyObjectSetType.d.ts

@@ -1,6 +1,6 @@
 import { AbstractLazyObjectType } from "./AbstractLazyObjectType.js";
 import type { SetType } from "./SetType.js";
 export declare class LazyObjectSetType extends AbstractLazyObjectType<SetType<AbstractLazyObjectType.ObjectTypeConstraint>, SetType<AbstractLazyObjectType.ObjectTypeConstraint>> {
-    readonly kind = "LazyObjectSetType";
+    readonly kind = "LazyObjectSet";
 }
 //# sourceMappingURL=LazyObjectSetType.d.ts.map

package/dist/ast/LazyObjectSetType.js

@@ -1,5 +1,5 @@
 import { AbstractLazyObjectType } from "./AbstractLazyObjectType.js";
 export class LazyObjectSetType extends AbstractLazyObjectType {
-    kind = "LazyObjectSetType";
+    kind = "LazyObjectSet";
 }
 //# sourceMappingURL=LazyObjectSetType.js.map

package/dist/ast/LazyObjectType.d.ts

@@ -1,5 +1,5 @@
 import { AbstractLazyObjectType } from "./AbstractLazyObjectType.js";
 export declare class LazyObjectType extends AbstractLazyObjectType<AbstractLazyObjectType.ObjectTypeConstraint, AbstractLazyObjectType.ObjectTypeConstraint> {
-    readonly kind = "LazyObjectType";
+    readonly kind = "LazyObject";
 }
 //# sourceMappingURL=LazyObjectType.d.ts.map

package/dist/ast/LazyObjectType.js

@@ -1,5 +1,5 @@
 import { AbstractLazyObjectType } from "./AbstractLazyObjectType.js";
 export class LazyObjectType extends AbstractLazyObjectType {
-    kind = "LazyObjectType";
+    kind = "LazyObject";
 }
 //# sourceMappingURL=LazyObjectType.js.map

package/dist/ast/ListType.d.ts

@@ -22,7 +22,7 @@ export declare class ListType<ItemTypeT extends ListType.ItemType = ListType.Ite
      * Type of identifier (blank or named node) to use for lists and sub-lists.
      */
     readonly identifierNodeKind: IdentifierNodeKind;
-    readonly kind = "ListType";
+    readonly kind = "List";
     /**
      * rdf:type's that will be added to this object when it's serialized toRdf.
      *

package/dist/ast/ListType.js

@@ -11,7 +11,7 @@ export class ListType extends AbstractCollectionType {
      * Type of identifier (blank or named node) to use for lists and sub-lists.
      */
     identifierNodeKind;
-    kind = "ListType";
+    kind = "List";
     /**
      * rdf:type's that will be added to this object when it's serialized toRdf.
      *
@@ -32,22 +32,22 @@ export class ListType extends AbstractCollectionType {
 (function (ListType) {
     function isItemType(type) {
         switch (type.kind) {
-            case "BlankNodeType":
-            case "IdentifierType":
-            case "IntersectionType":
-            case "IriType":
-            case "LiteralType":
-            case "ObjectType":
-            case "TermType":
-            case "UnionType":
+            case "BlankNode":
+            case "Identifier":
+            case "Intersection":
+            case "Iri":
+            case "Literal":
+            case "Object":
+            case "Term":
+            case "Union":
                 return true;
-            case "DefaultValueType":
-            case "LazyObjectOptionType":
-            case "LazyObjectSetType":
-            case "LazyObjectType":
-            case "ListType":
-            case "OptionType":
-            case "SetType":
+            case "DefaultValue":
+            case "LazyObjectOption":
+            case "LazyObjectSet":
+            case "LazyObject":
+            case "List":
+            case "Option":
+            case "Set":
                 return false;
         }
     }