@shaclmate/compiler 3.0.4 → 4.0.0

package/dist/ast/AbstractTermType.d.ts

@@ -0,0 +1,24 @@
+import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
+import type { NodeKind } from "@shaclmate/shacl-ast";
+import { AbstractType } from "./AbstractType.js";
+/**
+ * Abstract base class of term types (BlankNodeType, IdentifierType, LiteralType, IriType, TermType).
+ *
+ * ConstantTermT is the type of sh:defaultValue, sh:hasValue, and sh:in.
+ * RuntimeTermT is the type of values at runtime.
+ *
+ * The two are differentiated because identifiers can have BlankNode or NamedNode values at runtime but only NamedNode values for sh:defaultValue et al.
+ */
+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 nodeKinds: ReadonlySet<NodeKind>;
+    constructor({ hasValues, in_, ...superParameters }: {
+        hasValues: readonly ConstantTermT[];
+        in_: readonly ConstantTermT[];
+    } & ConstructorParameters<typeof AbstractType>[0]);
+    equals(other: AbstractTermType<ConstantTermT, _RuntimeTermT>): boolean;
+    toString(): string;
+}
+//# sourceMappingURL=AbstractTermType.d.ts.map

package/dist/ast/AbstractTermType.js

@@ -0,0 +1,41 @@
+import { AbstractType } from "./AbstractType.js";
+import { arrayEquals, setEquals, strictEquals, termEquals } from "./equals.js";
+/**
+ * Abstract base class of term types (BlankNodeType, IdentifierType, LiteralType, IriType, TermType).
+ *
+ * ConstantTermT is the type of sh:defaultValue, sh:hasValue, and sh:in.
+ * RuntimeTermT is the type of values at runtime.
+ *
+ * The two are differentiated because identifiers can have BlankNode or NamedNode values at runtime but only NamedNode values for sh:defaultValue et al.
+ */
+export class AbstractTermType extends AbstractType {
+    hasValues;
+    in_;
+    constructor({ hasValues, in_, ...superParameters }) {
+        super(superParameters);
+        this.hasValues = hasValues;
+        this.in_ = in_;
+    }
+    equals(other) {
+        if (!super.equals(other)) {
+            return false;
+        }
+        if (this.kind !== other.kind) {
+            return false;
+        }
+        if (!arrayEquals(termEquals)(this.hasValues, other.hasValues)) {
+            return false;
+        }
+        if (!arrayEquals(termEquals)(this.in_, other.in_)) {
+            return false;
+        }
+        if (!setEquals(strictEquals)(this.nodeKinds, other.nodeKinds)) {
+            return false;
+        }
+        return true;
+    }
+    toString() {
+        return `${this.kind}(nodeKinds=${[...this.nodeKinds].join(" | ")})`;
+    }
+}
+//# sourceMappingURL=AbstractTermType.js.map

package/dist/ast/AbstractType.d.ts

@@ -0,0 +1,21 @@
+import { Maybe } from "purify-ts";
+/**
+ * Abstract base class for Types.
+ */
+export declare abstract class AbstractType {
+    /**
+     * Documentation comment from rdfs:comment.
+     */
+    readonly comment: Maybe<string>;
+    /**
+     * Human-readable label from rdfs:label.
+     */
+    readonly label: Maybe<string>;
+    constructor({ comment, label, }: {
+        comment: Maybe<string>;
+        label: Maybe<string>;
+    });
+    equals(other: AbstractType): boolean;
+    abstract toString(): string;
+}
+//# sourceMappingURL=AbstractType.d.ts.map

package/dist/ast/AbstractType.js

@@ -0,0 +1,29 @@
+import { Maybe } from "purify-ts";
+import { maybeEquals, strictEquals } from "./equals.js";
+/**
+ * Abstract base class for Types.
+ */
+export class AbstractType {
+    /**
+     * Documentation comment from rdfs:comment.
+     */
+    comment = Maybe.empty();
+    /**
+     * Human-readable label from rdfs:label.
+     */
+    label = Maybe.empty();
+    constructor({ comment, label, }) {
+        this.comment = comment;
+        this.label = label;
+    }
+    equals(other) {
+        if (!maybeEquals(strictEquals)(this.comment, other.comment)) {
+            return false;
+        }
+        if (!maybeEquals(strictEquals)(this.label, other.label)) {
+            return false;
+        }
+        return true;
+    }
+}
+//# sourceMappingURL=AbstractType.js.map

package/dist/ast/BlankNodeType.d.ts

@@ -0,0 +1,11 @@
+import type { BlankNode, NamedNode } from "@rdfjs/types";
+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 nodeKinds: ReadonlySet<"BlankNode">;
+    constructor(superParameters: Pick<ConstructorParameters<typeof AbstractTermType<NamedNode, BlankNode>>[0], "comment" | "label">);
+}
+//# sourceMappingURL=BlankNodeType.d.ts.map

package/dist/ast/BlankNodeType.js

@@ -0,0 +1,17 @@
+import { AbstractTermType } from "./AbstractTermType.js";
+/**
+ * A type corresponding to sh:nodeKind sh:BlankNode.
+ */
+export class BlankNodeType extends AbstractTermType {
+    kind = "BlankNodeType";
+    nodeKinds = nodeKinds;
+    constructor(superParameters) {
+        super({
+            ...superParameters,
+            hasValues: [],
+            in_: [],
+        });
+    }
+}
+const nodeKinds = new Set(["BlankNode"]);
+//# sourceMappingURL=BlankNodeType.js.map

package/dist/ast/Curie.d.ts

@@ -1,14 +1,21 @@
+import type { BlankNode, NamedNode } from "@rdfjs/types";
 /**
  * A Compact URI (https://www.w3.org/TR/curie)
  */
-export declare class Curie {
+export declare class Curie implements NamedNode {
+    #private;
     readonly prefix: string;
     readonly reference: string;
-    constructor({ prefix, reference, }: {
+    readonly termType = "NamedNode";
+    readonly value: string;
+    constructor({ hasUniqueReference, prefix, reference, value, }: {
+        hasUniqueReference?: () => boolean;
         prefix: string;
         reference: string;
+        value: string;
     });
-    static parse(curie: string): Curie;
+    equals(other: BlankNode | NamedNode): boolean;
+    get hasUniqueReference(): boolean;
     toString(): string;
 }
 //# sourceMappingURL=Curie.d.ts.map

package/dist/ast/Curie.js

@@ -1,18 +1,26 @@
-import { invariant } from "ts-invariant";
 /**
  * A Compact URI (https://www.w3.org/TR/curie)
  */
 export class Curie {
     prefix;
+    #hasUniqueReference;
     reference;
-    constructor({ prefix, reference, }) {
+    termType = "NamedNode";
+    value;
+    constructor({ hasUniqueReference, prefix, reference, value, }) {
+        this.#hasUniqueReference = hasUniqueReference ?? (() => false);
         this.prefix = prefix;
         this.reference = reference;
+        this.value = value;
     }
-    static parse(curie) {
-        const split = curie.split(":", 2);
-        invariant(split.length === 2);
-        return new Curie({ prefix: split[0], reference: split[1] });
+    equals(other) {
+        if (other.termType === "BlankNode") {
+            return false;
+        }
+        return this.value === other.value; // Allow a Curie to equal a NamedNode
+    }
+    get hasUniqueReference() {
+        return this.#hasUniqueReference();
     }
     toString() {
         return `${this.prefix}:${this.reference}`;

package/dist/ast/DefaultValueType.d.ts

@@ -0,0 +1,26 @@
+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.
+ *
+ * This type is a hybrid of OptionType and a required (item) type like LiteralType.
+ *
+ * It's declared like the required type but is optional on deserialization/query since a default value
+ * can be substituted when one has not been supplied.
+ */
+export declare class DefaultValueType<ItemTypeT extends DefaultValueType.ItemType = DefaultValueType.ItemType> extends AbstractContainerType<ItemTypeT> {
+    readonly defaultValue: Literal | NamedNode;
+    readonly kind = "DefaultValueType";
+    constructor({ defaultValue, itemType, }: Pick<ConstructorParameters<typeof AbstractContainerType<ItemTypeT>>[0], "itemType"> & {
+        defaultValue: Literal | NamedNode;
+    });
+    equals(other: DefaultValueType<ItemTypeT>): boolean;
+}
+export declare namespace DefaultValueType {
+    type ItemType = Exclude<AbstractContainerType.ItemType, BlankNodeType | PlaceholderType>;
+    function isItemType(type: Type): type is ItemType;
+}
+//# sourceMappingURL=DefaultValueType.d.ts.map

package/dist/ast/DefaultValueType.js

@@ -0,0 +1,41 @@
+import { AbstractContainerType } from "./AbstractContainerType.js";
+import { termEquals } from "./equals.js";
+/**
+ * A type with an sh:defaultValue.
+ *
+ * This type is a hybrid of OptionType and a required (item) type like LiteralType.
+ *
+ * It's declared like the required type but is optional on deserialization/query since a default value
+ * can be substituted when one has not been supplied.
+ */
+export class DefaultValueType extends AbstractContainerType {
+    defaultValue;
+    kind = "DefaultValueType";
+    constructor({ defaultValue, itemType, }) {
+        super({
+            comment: itemType.comment,
+            itemType,
+            label: itemType.label,
+        });
+        this.defaultValue = defaultValue;
+    }
+    equals(other) {
+        if (!super.equals(other)) {
+            return false;
+        }
+        if (!termEquals(this.defaultValue, other.defaultValue)) {
+            return false;
+        }
+        return true;
+    }
+}
+(function (DefaultValueType) {
+    function isItemType(type) {
+        if (type.kind === "BlankNodeType") {
+            return false;
+        }
+        return AbstractContainerType.isItemType(type);
+    }
+    DefaultValueType.isItemType = isItemType;
+})(DefaultValueType || (DefaultValueType = {}));
+//# sourceMappingURL=DefaultValueType.js.map

package/dist/ast/IdentifierType.d.ts

@@ -1,11 +1,12 @@
 import type { BlankNode, NamedNode } from "@rdfjs/types";
 import type { IdentifierNodeKind } from "@shaclmate/shacl-ast";
-import type { TermType } from "./TermType.js";
+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 interface IdentifierType extends TermType<NamedNode, BlankNode | NamedNode> {
-    readonly kind: "IdentifierType";
-    readonly nodeKinds: Set<IdentifierNodeKind>;
+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">);
 }
 //# sourceMappingURL=IdentifierType.d.ts.map

package/dist/ast/IdentifierType.js

@@ -1,2 +1,20 @@
-export {};
+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";
+    nodeKinds = nodeKinds;
+    constructor(superParameters) {
+        super({
+            ...superParameters,
+            hasValues: [],
+            in_: [],
+        });
+    }
+}
+const nodeKinds = new Set([
+    "BlankNode",
+    "IRI",
+]);
 //# sourceMappingURL=IdentifierType.js.map

package/dist/ast/IntersectionType.d.ts

@@ -1,9 +1,9 @@
-import type { CompositeType } from "./CompositeType.js";
+import { AbstractCompoundType } from "./AbstractCompoundType.js";
 import type { Type } from "./Type.js";
 /**
  * A conjunction ("and") of types, corresponding to an sh:and.
  */
-export interface IntersectionType extends CompositeType<Type> {
-    readonly kind: "IntersectionType";
+export declare class IntersectionType extends AbstractCompoundType<Type> {
+    readonly kind = "IntersectionType";
 }
 //# sourceMappingURL=IntersectionType.d.ts.map

package/dist/ast/IntersectionType.js

@@ -1,2 +1,8 @@
-export {};
+import { AbstractCompoundType } from "./AbstractCompoundType.js";
+/**
+ * A conjunction ("and") of types, corresponding to an sh:and.
+ */
+export class IntersectionType extends AbstractCompoundType {
+    kind = "IntersectionType";
+}
 //# sourceMappingURL=IntersectionType.js.map

package/dist/ast/IriType.d.ts

@@ -0,0 +1,10 @@
+import type { NamedNode } from "@rdfjs/types";
+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 nodeKinds: ReadonlySet<"IRI">;
+}
+//# sourceMappingURL=IriType.d.ts.map

package/dist/ast/IriType.js

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

package/dist/ast/LazyObjectOptionType.d.ts

@@ -0,0 +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";
+}
+//# sourceMappingURL=LazyObjectOptionType.d.ts.map

package/dist/ast/LazyObjectOptionType.js

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

package/dist/ast/LazyObjectSetType.d.ts

@@ -0,0 +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";
+}
+//# sourceMappingURL=LazyObjectSetType.d.ts.map

package/dist/ast/LazyObjectSetType.js

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

package/dist/ast/LazyObjectType.d.ts

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

package/dist/ast/LazyObjectType.js

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

package/dist/ast/ListType.d.ts

@@ -1,9 +1,20 @@
-import type { NamedNode } from "@rdfjs/types";
+import type { BlankNode, NamedNode } from "@rdfjs/types";
 import type { IdentifierNodeKind } from "@shaclmate/shacl-ast";
 import type { Maybe } from "purify-ts";
 import type { IdentifierMintingStrategy } from "../enums/IdentifierMintingStrategy.js";
-import type { Name } from "./Name.js";
+import { AbstractCollectionType } from "./AbstractCollectionType.js";
+import type { BlankNodeType } from "./BlankNodeType.js";
+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";
 /**
  * An ordered sequence of items with zero or one values of an item type.
  *
@@ -11,38 +22,20 @@ import type { Type } from "./Type.js";
  *
  * Contrast SetType, which is transformed from any SHACL property shape with no maxCount or maxCount greater than 1.
  */
-export interface ListType {
-    /**
-     * Documentation comment from rdfs:comment.
-     */
-    readonly comment: Maybe<string>;
+export declare class ListType<ItemTypeT extends ListType.ItemType = ListType.ItemType> extends AbstractCollectionType<ItemTypeT> {
     /**
      * Type of identifier (blank or named node) to use for lists and sub-lists.
      */
     readonly identifierNodeKind: IdentifierNodeKind;
-    /**
-     * List item type.
-     *
-     * Mutable to support cycle-handling logic in the compiler.
-     */
-    itemType: Type;
-    readonly kind: "ListType";
-    /**
-     * Human-readable label from rdfs:label.
-     */
-    readonly label: Maybe<string>;
+    readonly kind = "ListType";
     /**
      * Strategy for minting new list and sub-list identifiers.
      */
     readonly identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
     /**
-     * The list should be mutable in generated code.
+     * Identifier of the node shape this type was derived from.
      */
-    readonly mutable: Maybe<boolean>;
-    /**
-     * Name of this type, usually derived from sh:name or shaclmate:name.
-     */
-    readonly name: Name;
+    readonly shapeIdentifier: BlankNode | NamedNode;
     /**
      * rdf:type's that will be added to this object when it's serialized toRdf.
      *
@@ -50,5 +43,16 @@ export interface ListType {
      * class targets).
      */
     readonly toRdfTypes: readonly NamedNode[];
+    constructor({ identifierMintingStrategy, identifierNodeKind, shapeIdentifier, toRdfTypes, ...superParameters }: {
+        identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
+        identifierNodeKind: IdentifierNodeKind;
+        shapeIdentifier: BlankNode | NamedNode;
+        toRdfTypes: readonly NamedNode[];
+    } & ConstructorParameters<typeof AbstractCollectionType<ItemTypeT>>[0]);
+    equals(other: ListType<ItemTypeT>): boolean;
+}
+export declare namespace ListType {
+    type ItemType = BlankNodeType | IdentifierType | IntersectionType | IriType | LiteralType | ObjectIntersectionType | ObjectType | ObjectUnionType | PlaceholderType | TermType | UnionType;
+    function isItemType(type: Type): type is ItemType;
 }
 //# sourceMappingURL=ListType.d.ts.map

package/dist/ast/ListType.js

@@ -1,2 +1,69 @@
-export {};
+import { AbstractCollectionType } from "./AbstractCollectionType.js";
+/**
+ * An ordered sequence of items with zero or one values of an item type.
+ *
+ * ListType is transformed from a SHACL node shape that models an RDF list (https://www.w3.org/TR/rdf11-schema/#ch_collectionvocab).
+ *
+ * Contrast SetType, which is transformed from any SHACL property shape with no maxCount or maxCount greater than 1.
+ */
+export class ListType extends AbstractCollectionType {
+    /**
+     * Type of identifier (blank or named node) to use for lists and sub-lists.
+     */
+    identifierNodeKind;
+    kind = "ListType";
+    /**
+     * 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.
+     *
+     * This is usually the identifier of an sh:NodeShape that is also an rdfs:Class (i.e., a node shape with implicit
+     * class targets).
+     */
+    toRdfTypes;
+    constructor({ identifierMintingStrategy, identifierNodeKind, shapeIdentifier, toRdfTypes, ...superParameters }) {
+        super(superParameters);
+        this.identifierMintingStrategy = identifierMintingStrategy;
+        this.identifierNodeKind = identifierNodeKind;
+        this.shapeIdentifier = shapeIdentifier;
+        this.toRdfTypes = toRdfTypes;
+    }
+    equals(other) {
+        // Don't recurse
+        return this.shapeIdentifier.equals(other.shapeIdentifier);
+    }
+}
+(function (ListType) {
+    function isItemType(type) {
+        switch (type.kind) {
+            case "BlankNodeType":
+            case "IdentifierType":
+            case "IntersectionType":
+            case "IriType":
+            case "LiteralType":
+            case "ObjectIntersectionType":
+            case "ObjectType":
+            case "ObjectUnionType":
+            case "PlaceholderType":
+            case "TermType":
+            case "UnionType":
+                return true;
+            case "DefaultValueType":
+            case "LazyObjectOptionType":
+            case "LazyObjectSetType":
+            case "LazyObjectType":
+            case "ListType":
+            case "OptionType":
+            case "SetType":
+                return false;
+        }
+    }
+    ListType.isItemType = isItemType;
+})(ListType || (ListType = {}));
 //# sourceMappingURL=ListType.js.map

package/dist/ast/LiteralType.d.ts

@@ -1,14 +1,23 @@
 import type { Literal, NamedNode } from "@rdfjs/types";
 import type { Maybe } from "purify-ts";
-import type { TermType } from "./TermType.js";
-export interface LiteralType extends TermType<Literal, Literal> {
+import { AbstractTermType } from "./AbstractTermType.js";
+export declare class LiteralType extends AbstractTermType<Literal, Literal> {
     readonly datatype: Maybe<NamedNode>;
-    readonly kind: "LiteralType";
+    readonly kind = "LiteralType";
+    readonly nodeKinds: ReadonlySet<"Literal">;
     readonly languageIn: readonly string[];
     readonly maxExclusive: Maybe<Literal>;
     readonly maxInclusive: Maybe<Literal>;
     readonly minExclusive: Maybe<Literal>;
     readonly minInclusive: Maybe<Literal>;
-    readonly nodeKinds: Set<"Literal">;
+    constructor({ datatype, languageIn, maxExclusive, maxInclusive, minExclusive, minInclusive, ...superParameters }: {
+        datatype: Maybe<NamedNode>;
+        languageIn: readonly string[];
+        maxExclusive: Maybe<Literal>;
+        maxInclusive: Maybe<Literal>;
+        minExclusive: Maybe<Literal>;
+        minInclusive: Maybe<Literal>;
+    } & Omit<ConstructorParameters<typeof AbstractTermType<Literal, Literal>>[0], "nodeKinds">);
+    toString(): string;
 }
 //# sourceMappingURL=LiteralType.d.ts.map

package/dist/ast/LiteralType.js

@@ -1,2 +1,25 @@
-export {};
+import { AbstractTermType } from "./AbstractTermType.js";
+export class LiteralType extends AbstractTermType {
+    datatype;
+    kind = "LiteralType";
+    nodeKinds = nodeKinds;
+    languageIn;
+    maxExclusive;
+    maxInclusive;
+    minExclusive;
+    minInclusive;
+    constructor({ datatype, languageIn, maxExclusive, maxInclusive, minExclusive, minInclusive, ...superParameters }) {
+        super(superParameters);
+        this.datatype = datatype;
+        this.languageIn = languageIn;
+        this.maxExclusive = maxExclusive;
+        this.maxInclusive = maxInclusive;
+        this.minExclusive = minExclusive;
+        this.minInclusive = minInclusive;
+    }
+    toString() {
+        return `${this.kind}()`;
+    }
+}
+const nodeKinds = new Set(["Literal"]);
 //# sourceMappingURL=LiteralType.js.map

package/dist/ast/ObjectIntersectionType.d.ts

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

package/dist/ast/ObjectIntersectionType.js

@@ -1,2 +1,8 @@
-export {};
+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";
+}
 //# sourceMappingURL=ObjectIntersectionType.js.map