@shaclmate/compiler 4.0.50 → 4.0.51

package/dist/ast/AbstractLazyType.d.ts

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

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

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

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

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

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

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Ast.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 = "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

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

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

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

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

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

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

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

@@ -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 = "Iri";
+    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 = "Iri";
+    nodeKinds = nodeKinds;
+}
+const nodeKinds = new Set(["IRI"]);
+//# sourceMappingURL=IriType.js.map

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

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