@shaclmate/compiler 4.0.48 → 4.0.50

package/dist/ast/AbstractLazyType.d.ts

@@ -1,117 +0,0 @@
-import type { NodeKind } from "@shaclmate/shacl-ast";
-import { AbstractType } from "./AbstractType.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 LazyOptionType, LazySetType, and LazyType.
- */
-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 }: {
-        partialType: PartialTypeT;
-        resolveType: ResolveTypeT;
-    } & ConstructorParameters<typeof AbstractType>[0]);
-    get nodeKinds(): ReadonlySet<NodeKind>;
-    get recursive(): boolean;
-    equals(other: AbstractLazyType<PartialTypeT, ResolveTypeT>): boolean;
-    toJSON(): {
-        partialType: {
-            fromRdfType: import("@rdfjs/types").NamedNode<string> | undefined;
-            identifierType: {
-                hasValues: readonly import("@rdfjs/types").NamedNode<string>[] | undefined;
-                in: readonly import("@rdfjs/types").NamedNode<string>[] | undefined;
-                nodeKinds: NodeKind[];
-                comment: string | undefined;
-                kind: string;
-                label: string | undefined;
-                name: string | undefined;
-                recursive: boolean | undefined;
-                shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
-            };
-            synthetic: boolean | undefined;
-            toRdfTypes: readonly import("@rdfjs/types").NamedNode<string>[] | undefined;
-            comment: string | undefined;
-            kind: string;
-            label: string | undefined;
-            name: string | undefined;
-            recursive: boolean | undefined;
-            shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
-        } | {
-            members: {
-                discriminantValue: string | number | undefined;
-                type: any;
-            }[] | undefined;
-            comment: string | undefined;
-            kind: string;
-            label: string | undefined;
-            name: string | undefined;
-            recursive: boolean | undefined;
-            shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
-        } | {
-            itemType: any;
-            comment: string | undefined;
-            kind: string;
-            label: string | undefined;
-            name: string | undefined;
-            recursive: boolean | undefined;
-            shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
-        };
-        resolveType: {
-            fromRdfType: import("@rdfjs/types").NamedNode<string> | undefined;
-            identifierType: {
-                hasValues: readonly import("@rdfjs/types").NamedNode<string>[] | undefined;
-                in: readonly import("@rdfjs/types").NamedNode<string>[] | undefined;
-                nodeKinds: NodeKind[];
-                comment: string | undefined;
-                kind: string;
-                label: string | undefined;
-                name: string | undefined;
-                recursive: boolean | undefined;
-                shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
-            };
-            synthetic: boolean | undefined;
-            toRdfTypes: readonly import("@rdfjs/types").NamedNode<string>[] | undefined;
-            comment: string | undefined;
-            kind: string;
-            label: string | undefined;
-            name: string | undefined;
-            recursive: boolean | undefined;
-            shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
-        } | {
-            members: {
-                discriminantValue: string | number | undefined;
-                type: any;
-            }[] | undefined;
-            comment: string | undefined;
-            kind: string;
-            label: string | undefined;
-            name: string | undefined;
-            recursive: boolean | undefined;
-            shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
-        } | {
-            itemType: any;
-            comment: string | undefined;
-            kind: string;
-            label: string | undefined;
-            name: string | undefined;
-            recursive: boolean | undefined;
-            shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
-        };
-        comment: string | undefined;
-        kind: string;
-        label: string | undefined;
-        name: string | undefined;
-        recursive: boolean | undefined;
-        shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
-    };
-}
-export declare namespace AbstractLazyType {
-    type ItemTypeConstraint = StructType | StructUnionType;
-    type PartialTypeConstraint = ItemTypeConstraint | OptionType<ItemTypeConstraint> | SetType<ItemTypeConstraint>;
-    type ResolveTypeConstraint = PartialTypeConstraint;
-}
-//# sourceMappingURL=AbstractLazyType.d.ts.map

package/dist/ast/AbstractLazyType.js

@@ -1,40 +0,0 @@
-import { AbstractType } from "./AbstractType.js";
-import { Type } from "./Type.js";
-/**
- * Abstract base class of LazyOptionType, LazySetType, and LazyType.
- */
-export class AbstractLazyType extends AbstractType {
-    partialType;
-    resolveType;
-    constructor({ partialType, resolveType, ...superParameters }) {
-        super(superParameters);
-        this.partialType = partialType;
-        this.resolveType = resolveType;
-    }
-    get nodeKinds() {
-        return this.partialType.nodeKinds;
-    }
-    get recursive() {
-        return this.partialType.recursive;
-    }
-    equals(other) {
-        if (!super.equals(other)) {
-            return false;
-        }
-        if (!Type.equals(this.partialType, other.partialType)) {
-            return false;
-        }
-        if (!Type.equals(this.resolveType, other.resolveType)) {
-            return false;
-        }
-        return true;
-    }
-    toJSON() {
-        return {
-            ...super.toJSON(),
-            partialType: this.partialType.toJSON(),
-            resolveType: this.resolveType.toJSON(),
-        };
-    }
-}
-//# sourceMappingURL=AbstractLazyType.js.map

package/dist/ast/AbstractTermType.d.ts

@@ -1,33 +0,0 @@
-import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
-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: "BlankNode" | "Identifier" | "Iri" | "Literal" | "Term";
-    readonly recursive = false;
-    constructor({ hasValues, in_, ...superParameters }: {
-        hasValues: readonly ConstantTermT[];
-        in_: readonly ConstantTermT[];
-    } & ConstructorParameters<typeof AbstractType>[0]);
-    equals(other: AbstractTermType<ConstantTermT, _RuntimeTermT>): boolean;
-    toJSON(): {
-        hasValues: readonly ConstantTermT[] | undefined;
-        in: readonly ConstantTermT[] | undefined;
-        nodeKinds: import("@shaclmate/shacl-ast").NodeKind[];
-        comment: string | undefined;
-        kind: string;
-        label: string | undefined;
-        name: string | undefined;
-        recursive: boolean | undefined;
-        shapeIdentifier: BlankNode | NamedNode<string>;
-    };
-}
-//# sourceMappingURL=AbstractTermType.d.ts.map

package/dist/ast/AbstractTermType.js

@@ -1,47 +0,0 @@
-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_;
-    recursive = false;
-    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;
-    }
-    toJSON() {
-        return {
-            ...super.toJSON(),
-            hasValues: this.hasValues.length > 0 ? this.hasValues : undefined,
-            in: this.in_.length > 0 ? this.in_ : undefined,
-            nodeKinds: [...this.nodeKinds],
-        };
-    }
-}
-//# sourceMappingURL=AbstractTermType.js.map

package/dist/ast/AbstractType.d.ts

@@ -1,55 +0,0 @@
-import type { BlankNode, NamedNode } from "@rdfjs/types";
-import type { NodeKind } from "@shaclmate/shacl-ast";
-import { Maybe } from "purify-ts";
-/**
- * Abstract base class for Types.
- */
-export declare abstract class AbstractType {
-    /**
-     * Documentation comment from rdfs:comment.
-     */
-    readonly comment: Maybe<string>;
-    /**
-     * Type discriminant
-     */
-    abstract readonly kind: string;
-    /**
-     * Human-readable label from rdfs:label.
-     */
-    readonly label: Maybe<string>;
-    /**
-     * Name of this type, from shaclmate:name or sh:name.
-     */
-    readonly name: Maybe<string>;
-    /**
-     * The range of node kinds of this type.
-     *
-     * 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>;
-    /**
-     * 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;
-    toJSON(): {
-        comment: string | undefined;
-        kind: string;
-        label: string | undefined;
-        name: string | undefined;
-        recursive: boolean | undefined;
-        shapeIdentifier: BlankNode | NamedNode<string>;
-    };
-    toString(): string;
-}
-//# sourceMappingURL=AbstractType.d.ts.map

package/dist/ast/AbstractType.js

@@ -1,55 +0,0 @@
-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();
-    /**
-     * 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)) {
-            return false;
-        }
-        if (!maybeEquals(strictEquals)(this.label, other.label)) {
-            return false;
-        }
-        if (!maybeEquals(strictEquals)(this.name, other.name)) {
-            return false;
-        }
-        return true;
-    }
-    toJSON() {
-        return {
-            comment: this.comment.extract(),
-            kind: this.kind,
-            label: this.label.extract(),
-            name: this.name.extract(),
-            recursive: this.recursive ? true : undefined,
-            shapeIdentifier: this.shapeIdentifier,
-        };
-    }
-    toString() {
-        return JSON.stringify(this.toJSON());
-    }
-}
-//# sourceMappingURL=AbstractType.js.map

package/dist/ast/Ast.d.ts

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

package/dist/ast/Ast.js

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

package/dist/ast/BlankNodeType.d.ts

@@ -1,11 +0,0 @@
-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 = "BlankNode";
-    readonly nodeKinds: ReadonlySet<"BlankNode">;
-    constructor(superParameters: Omit<ConstructorParameters<typeof AbstractTermType<NamedNode, BlankNode>>[0], "hasValues" | "in_">);
-}
-//# sourceMappingURL=BlankNodeType.d.ts.map

package/dist/ast/BlankNodeType.js

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

package/dist/ast/DefaultValueType.d.ts

@@ -1,35 +0,0 @@
-import type { Literal, NamedNode } from "@rdfjs/types";
-import { AbstractContainerType } from "./AbstractContainerType.js";
-import type { BlankNodeType } from "./BlankNodeType.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 = "DefaultValue";
-    constructor({ defaultValue, itemType, }: Pick<ConstructorParameters<typeof AbstractContainerType<ItemTypeT>>[0], "itemType"> & {
-        defaultValue: Literal | NamedNode;
-    });
-    equals(other: DefaultValueType<ItemTypeT>): boolean;
-    toJSON(): {
-        defaultValue: Literal | NamedNode<string>;
-        itemType: any;
-        comment: string | undefined;
-        kind: string;
-        label: string | undefined;
-        name: string | undefined;
-        recursive: boolean | undefined;
-        shapeIdentifier: import("@rdfjs/types").BlankNode | NamedNode<string>;
-    };
-}
-export declare namespace DefaultValueType {
-    type ItemType = Exclude<AbstractContainerType.ItemType, BlankNodeType>;
-    function isItemType(type: Type): type is ItemType;
-}
-//# sourceMappingURL=DefaultValueType.d.ts.map

package/dist/ast/DefaultValueType.js

@@ -1,50 +0,0 @@
-import { Maybe } from "purify-ts";
-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 = "DefaultValue";
-    constructor({ defaultValue, itemType, }) {
-        super({
-            comment: itemType.comment,
-            itemType,
-            label: itemType.label,
-            name: Maybe.empty(),
-            shapeIdentifier: itemType.shapeIdentifier,
-        });
-        this.defaultValue = defaultValue;
-    }
-    equals(other) {
-        if (!super.equals(other)) {
-            return false;
-        }
-        if (!termEquals(this.defaultValue, other.defaultValue)) {
-            return false;
-        }
-        return true;
-    }
-    toJSON() {
-        return {
-            ...super.toJSON(),
-            defaultValue: this.defaultValue,
-        };
-    }
-}
-(function (DefaultValueType) {
-    function isItemType(type) {
-        if (type.kind === "BlankNode") {
-            return false;
-        }
-        return AbstractContainerType.isItemType(type);
-    }
-    DefaultValueType.isItemType = isItemType;
-})(DefaultValueType || (DefaultValueType = {}));
-//# sourceMappingURL=DefaultValueType.js.map

package/dist/ast/IdentifierType.d.ts

@@ -1,12 +0,0 @@
-import type { BlankNode, NamedNode } from "@rdfjs/types";
-import type { IdentifierNodeKind } from "@shaclmate/shacl-ast";
-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 = "Identifier";
-    readonly nodeKinds: ReadonlySet<IdentifierNodeKind>;
-    constructor(superParameters: Omit<ConstructorParameters<typeof AbstractTermType<NamedNode, BlankNode>>[0], "hasValues" | "in_">);
-}
-//# sourceMappingURL=IdentifierType.d.ts.map

package/dist/ast/IdentifierType.js

@@ -1,20 +0,0 @@
-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 = "Identifier";
-    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,14 +0,0 @@
-import { AbstractCompoundType } from "./AbstractCompoundType.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";
-    isStructIntersectionType(): this is StructIntersectionType;
-}
-export declare namespace IntersectionType {
-    type MemberType = AbstractCompoundType.MemberType;
-    const isMemberType: typeof AbstractCompoundType.isMemberType;
-}
-//# sourceMappingURL=IntersectionType.d.ts.map

package/dist/ast/IntersectionType.js

@@ -1,17 +0,0 @@
-import { AbstractCompoundType } from "./AbstractCompoundType.js";
-/**
- * A conjunction ("and") of types, corresponding to an sh:and.
- */
-export class IntersectionType extends AbstractCompoundType {
-    kind = "Intersection";
-    isStructIntersectionType() {
-        return (this.members.length > 0 &&
-            this.members.every((member) => member.type.kind === "Struct" ||
-                (member.type.kind === "Intersection" &&
-                    member.type.isStructIntersectionType())));
-    }
-}
-(function (IntersectionType) {
-    IntersectionType.isMemberType = AbstractCompoundType.isMemberType;
-})(IntersectionType || (IntersectionType = {}));
-//# sourceMappingURL=IntersectionType.js.map

package/dist/ast/IriType.d.ts

@@ -1,10 +0,0 @@
-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 = "Iri";
-    readonly nodeKinds: ReadonlySet<"IRI">;
-}
-//# sourceMappingURL=IriType.d.ts.map

package/dist/ast/IriType.js

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

package/dist/ast/LazyOptionType.d.ts

@@ -1,6 +0,0 @@
-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

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

package/dist/ast/LazySetType.d.ts

@@ -1,6 +0,0 @@
-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

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

package/dist/ast/LazyType.d.ts

@@ -1,5 +0,0 @@
-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

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

package/dist/ast/ListType.d.ts

@@ -1,44 +0,0 @@
-import type { BlankNode, NamedNode } from "@rdfjs/types";
-import type { IdentifierNodeKind } from "@shaclmate/shacl-ast";
-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 { StructType } from "./StructType.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.
- *
- * 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 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;
-    readonly kind = "List";
-    /**
-     * 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).
-     */
-    readonly toRdfTypes: readonly NamedNode[];
-    constructor({ identifierNodeKind, toRdfTypes, ...superParameters }: {
-        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 | ListType | LiteralType | StructType | TermType | UnionType;
-    function isItemType(type: Type): type is ItemType;
-}
-//# sourceMappingURL=ListType.d.ts.map