@shaclmate/compiler 2.0.13 → 2.0.15

package/_ShapesGraphToAstTransformer/transformPropertyShapeToAstType.js

@@ -0,0 +1,58 @@
+import { invariant } from "ts-invariant";
+import * as input from "../input/index.js";
+/**
+ * Try to convert a property shape to a type using some heuristics.
+ *
+ * We don't try to handle exotic cases allowed by the SHACL spec, such as combinations of sh:in and sh:node. Instead we assume
+ * a shape has one type.
+ */
+export function transformPropertyShapeToAstType(shape, inherited) {
+    // Try to transform the property shape into an AST type without cardinality constraints
+    return this.transformPropertyShapeToAstCompositeType(shape, inherited)
+        .altLazy(() => this.transformPropertyShapeToAstIdentifierType(shape, inherited))
+        .altLazy(() => this.transformPropertyShapeToAstLiteralType(shape, inherited))
+        .altLazy(() => this.transformPropertyShapeToAstTermType(shape, inherited))
+        .map((itemType) => {
+        // Handle cardinality constraints
+        if ((shape instanceof input.PropertyShape && shape.defaultValue.isJust()) ||
+            inherited?.defaultValue.isJust()) {
+            // Ignore other cardinality constraints if there's a default value and treat the type as minCount=maxCount=1
+            return itemType;
+        }
+        const maxCount = shape.constraints.maxCount;
+        const minCount = shape.constraints.minCount;
+        if (maxCount.isNothing() && minCount.isNothing()) {
+            // The shape has no cardinality constraints
+            if (inherited === null) {
+                // The shape is top-level (not an sh:xone/sh:and of a top-level shape)
+                // Treat it as a Set, the default in RDF.
+                // We want Set to be the outermost type unless it's explicitly requested with sh:minCount 0.
+                return {
+                    itemType,
+                    kind: "SetType",
+                    minCount: 0,
+                };
+            }
+            // else the shape is not top-level
+            // We want Set to be the outermost type, so just return the itemType here
+            return itemType;
+        }
+        if (minCount.orDefault(0) === 0 && maxCount.extractNullable() === 1) {
+            return {
+                itemType,
+                kind: "OptionType",
+            };
+        }
+        if (minCount.orDefault(0) === 1 && maxCount.extractNullable() === 1) {
+            return itemType;
+        }
+        invariant(minCount.isJust() || maxCount.isJust());
+        // There are cardinality constraints for a Set. It may be an inner type.
+        return {
+            itemType,
+            kind: "SetType",
+            minCount: minCount.orDefault(0),
+        };
+    });
+}
+//# sourceMappingURL=transformPropertyShapeToAstType.js.map

package/ast/Ast.d.ts

@@ -1,5 +1,10 @@
+import type { ObjectIntersectionType } from "./ObjectIntersectionType.js";
 import type { ObjectType } from "./ObjectType.js";
+import type { ObjectUnionType } from "./ObjectUnionType.js";
 export interface Ast {
+    readonly objectIntersectionTypes: readonly ObjectIntersectionType[];
     readonly objectTypes: readonly ObjectType[];
+    readonly objectUnionTypes: readonly ObjectUnionType[];
+    readonly tsDataFactoryVariable: string;
 }
 //# sourceMappingURL=Ast.d.ts.map

package/ast/CompositeType.d.ts

@@ -0,0 +1,13 @@
+import type { Type } from "./Type.js";
+/**
+ * A composite of types, such as an intersection or union.
+ */
+export interface CompositeType<MemberTypeT extends Type> {
+    /**
+     * Member types.
+     *
+     * Mutable to support cycle-handling logic in the compiler.
+     */
+    readonly memberTypes: MemberTypeT[];
+}
+//# sourceMappingURL=CompositeType.d.ts.map

package/ast/CompositeType.js

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

package/ast/IdentifierType.d.ts

@@ -1,13 +1,10 @@
 import type { BlankNode, NamedNode } from "@rdfjs/types";
-import type { NodeKind } from "@shaclmate/shacl-ast";
-import type { Maybe } from "purify-ts";
+import type { TermType } from "./TermType.js";
 /**
  * A type corresponding to sh:nodeKind of a blank node or IRI, and not corresponding to a node shape.
  */
-export interface IdentifierType {
-    readonly defaultValue: Maybe<BlankNode | NamedNode>;
-    readonly hasValue: Maybe<BlankNode | NamedNode>;
+export interface IdentifierType extends TermType<BlankNode | NamedNode> {
     readonly kind: "IdentifierType";
-    readonly nodeKinds: Set<NodeKind.BLANK_NODE | NodeKind.IRI>;
+    readonly nodeKinds: Set<"BlankNode" | "NamedNode">;
 }
 //# sourceMappingURL=IdentifierType.d.ts.map

package/ast/IntersectionType.d.ts

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

package/ast/ListType.d.ts

@@ -0,0 +1,53 @@
+import type { NamedNode } from "@rdfjs/types";
+import type { Maybe } from "purify-ts";
+import type { MintingStrategy } from "../enums/MintingStrategy.js";
+import type { Name } from "./Name.js";
+import type { Type } from "./Type.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 interface ListType {
+    /**
+     * Documentation comment from rdfs:comment.
+     */
+    readonly comment: Maybe<string>;
+    /**
+     * Type of identifier (blank or named node) to use for lists and sub-lists.
+     */
+    readonly identifierNodeKind: "BlankNode" | "NamedNode";
+    /**
+     * 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>;
+    /**
+     * Strategy for minting new list and sub-list identifiers.
+     */
+    readonly mintingStrategy: Maybe<MintingStrategy>;
+    /**
+     * The list should be mutable in generated code.
+     */
+    readonly mutable: Maybe<boolean>;
+    /**
+     * Name of this type, usually derived from sh:name or shaclmate:name.
+     */
+    readonly name: Name;
+    /**
+     * 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[];
+}
+//# sourceMappingURL=ListType.d.ts.map

package/ast/ListType.js

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

package/ast/LiteralType.d.ts

@@ -1,13 +1,14 @@
 import type { Literal, NamedNode } from "@rdfjs/types";
 import type { Maybe } from "purify-ts";
-export interface LiteralType {
+import type { TermType } from "./TermType.js";
+export interface LiteralType extends TermType<Literal> {
     readonly datatype: Maybe<NamedNode>;
-    readonly defaultValue: Maybe<Literal>;
-    readonly hasValue: Maybe<Literal>;
     readonly kind: "LiteralType";
+    readonly languageIn: readonly string[];
     readonly maxExclusive: Maybe<Literal>;
     readonly maxInclusive: Maybe<Literal>;
     readonly minExclusive: Maybe<Literal>;
     readonly minInclusive: Maybe<Literal>;
+    readonly nodeKinds: Set<"Literal">;
 }
 //# sourceMappingURL=LiteralType.d.ts.map

package/ast/Name.d.ts

@@ -3,6 +3,7 @@ import type { Maybe } from "purify-ts";
 export interface Name {
     readonly curie: Maybe<string>;
     readonly identifier: BlankNode | NamedNode;
+    readonly label: Maybe<string>;
     readonly propertyPath: Maybe<{
         curie: Maybe<string>;
         identifier: NamedNode;

package/ast/ObjectCompositeType.d.ts

@@ -0,0 +1,22 @@
+import type { Maybe } from "purify-ts";
+import type { CompositeType } from "./CompositeType.js";
+import type { Name } from "./Name.js";
+import type { ObjectType } from "./ObjectType.js";
+/**
+ * A composite of object types, such as an intersection or union.
+ */
+export interface ObjectCompositeType extends CompositeType<ObjectType> {
+    /**
+     * Documentation comment from rdfs:comment.
+     */
+    readonly comment: Maybe<string>;
+    /**
+     * Human-readable label from rdfs:label.
+     */
+    readonly label: Maybe<string>;
+    /**
+     * Name of this type, usually derived from sh:name or shaclmate:name.
+     */
+    readonly name: Name;
+}
+//# sourceMappingURL=ObjectCompositeType.d.ts.map

package/ast/ObjectCompositeType.js

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

package/ast/ObjectIntersectionType.d.ts

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

package/ast/ObjectIntersectionType.js

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

package/ast/ObjectType.d.ts

@@ -1,9 +1,9 @@
 import type { NamedNode } from "@rdfjs/types";
-import type { NodeKind } from "@shaclmate/shacl-ast";
 import type { PredicatePath } from "@shaclmate/shacl-ast";
 import type { Maybe } from "purify-ts";
-import type { Name, Type } from ".";
-import type { MintingStrategy } from "./MintingStrategy";
+import type { MintingStrategy, PropertyVisibility, TsFeature, TsObjectDeclarationType } from "../enums/index.js";
+import type { Name } from "./Name.js";
+import type { Type } from "./Type.js";
 export interface ObjectType {
     /**
      * Classes generated from this type are abstract / cannot be instantiated themselves.
@@ -14,19 +14,23 @@ export interface ObjectType {
     /**
      * Ancestor (parents, their parents, ad nauseum) ObjectTypes of this ObjectType.
      *
-     * Mutable to support cycle-handling logic in the transformer.
+     * Mutable to support cycle-handling logic in the compiler.
      */
     readonly ancestorObjectTypes: ObjectType[];
     /**
      * Immediate child ObjectTypes of this ObjectType.
      *
-     * Mutable to support cycle-handling logic in the transformer.
+     * Mutable to support cycle-handling logic in the compiler.
      */
     readonly childObjectTypes: ObjectType[];
+    /**
+     * Documentation comment from rdfs:comment.
+     */
+    readonly comment: Maybe<string>;
     /**
      * Descendant (children, their children, ad nauseum) ObjectTypes of this ObjectType.
      *
-     * Mutable to support cycle-handling logic in the transformer.
+     * Mutable to support cycle-handling logic in the compiler.
      */
     readonly descendantObjectTypes: ObjectType[];
     /**
@@ -35,20 +39,33 @@ export interface ObjectType {
      * Defaults to true.
      */
     readonly export: boolean;
-    readonly kind: "ObjectType";
     /**
-     * If the ObjectType is an RDF list, this is the type of rdf:first.
-     * https://www.w3.org/TR/rdf-schema/#ch_collectionvocab
+     * If true, the code for this ObjectType is defined externally and should not be generated.
+     *
+     * Defaults to false.
+     */
+    readonly extern: boolean;
+    /**
+     * The expected rdf:type of instances of this ObjectType.
      *
-     * Mutable to support cycle-handling logic in the transformer.
+     * 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 fromRdfType: Maybe<NamedNode>;
+    /**
+     * Type discriminator.
+     */
+    readonly kind: "ObjectType";
+    /**
+     * Human-readable label from rdfs:label.
      */
-    listItemType: Maybe<Type>;
+    readonly label: Maybe<string>;
     /**
-     * Strategy for minting new object identifiers. If not specified, require an identifier on construction.
+     * Strategy for minting new object identifiers.
      */
     readonly mintingStrategy: Maybe<MintingStrategy>;
     /**
-     * Name of this ObjectType, usually derived from sh:name or shaclmate:name.
+     * Name of this type, usually derived from sh:name or shaclmate:name.
      */
     readonly name: Name;
     /**
@@ -56,33 +73,88 @@ export interface ObjectType {
      *
      * Used to associate instances with an RDF identifier.
      */
-    readonly nodeKinds: Set<NodeKind.BLANK_NODE | NodeKind.IRI>;
+    readonly nodeKinds: Set<"BlankNode" | "NamedNode">;
     /**
      * Immediate parent ObjectTypes of this Object types.
      *
-     * Mutable to support cycle-handling logic in the transformer.
+     * Mutable to support cycle-handling logic in the compiler.
      */
     readonly parentObjectTypes: ObjectType[];
     /**
      * Properties of this ObjectType.
      *
-     * Mutable to support cycle-handling logic in the transformer.
+     * Mutable to support cycle-handling logic in the compiler.
      */
     readonly properties: ObjectType.Property[];
     /**
-     * The expected rdf:type of instances of this ObjectType.
+     * 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 rdfType: Maybe<NamedNode>;
+    readonly toRdfTypes: readonly NamedNode[];
+    /**
+     * TypeScript features to generate.
+     */
+    readonly tsFeatures: Set<TsFeature>;
+    /**
+     * Name of the identifier property in TypeScript-generated classes/interfaces.
+     */
+    readonly tsIdentifierPropertyName: string;
+    /**
+     * TypeScript imports to add to generated code.
+     *
+     * This is often used in conjunction with extern=true to import the extern'd ObjectType code in order for generated
+     * code to reference it.
+     *
+     * import { MyType } from "./MyType.js"
+     */
+    readonly tsImports: readonly string[];
+    /**
+     * Whether to generate a TypeScript class or interface for this type.
+     */
+    readonly tsObjectDeclarationType: TsObjectDeclarationType;
+    /**
+     * Name of the type discriminator property in TypeScript-generated classes/interfaces.
+     */
+    readonly tsTypeDiscriminatorPropertyName: string;
 }
 export declare namespace ObjectType {
     interface Property {
-        readonly inline: boolean;
+        /**
+         * Documentation comment from rdfs:comment.
+         */
+        readonly comment: Maybe<string>;
+        /**
+         * Description from sh:description.
+         */
+        readonly description: Maybe<string>;
+        /**
+         * Human-readable label from rdfs:label.
+         */
+        readonly label: Maybe<string>;
+        /**
+         * The property should be mutable in generated code i.e., it should be re-assignable. The property value may or may
+         * not be mutable.
+         */
+        readonly mutable: Maybe<boolean>;
+        /**
+         * Name of this property.
+         */
         readonly name: Name;
+        /**
+         * SHACL property path (https://www.w3.org/TR/shacl/#property-paths)
+         */
         readonly path: PredicatePath;
+        /**
+         * Type of this property.
+         */
         readonly type: Type;
+        /**
+         * Visibility: private, protected, public.
+         */
+        readonly visibility: PropertyVisibility;
     }
+    function toposort(objectTypes: readonly ObjectType[]): readonly ObjectType[];
 }
 //# sourceMappingURL=ObjectType.d.ts.map

package/ast/ObjectType.js

@@ -1,2 +1,27 @@
-export {};
+import { Resource } from "rdfjs-resource";
+import genericToposort from "toposort";
+export var ObjectType;
+(function (ObjectType) {
+    function toposort(objectTypes) {
+        const objectTypesByIdentifier = {};
+        const objectTypeGraphNodes = [];
+        const objectTypeGraphEdges = [];
+        for (const objectType of objectTypes) {
+            const objectTypeIdentifier = Resource.Identifier.toString(objectType.name.identifier);
+            objectTypesByIdentifier[objectTypeIdentifier] = objectType;
+            objectTypeGraphNodes.push(objectTypeIdentifier);
+            for (const parentAstObjectType of objectType.parentObjectTypes) {
+                objectTypeGraphEdges.push([
+                    objectTypeIdentifier,
+                    Resource.Identifier.toString(parentAstObjectType.name.identifier),
+                ]);
+            }
+        }
+        return genericToposort
+            .array(objectTypeGraphNodes, objectTypeGraphEdges)
+            .map((objectTypeIdentifier) => objectTypesByIdentifier[objectTypeIdentifier])
+            .reverse();
+    }
+    ObjectType.toposort = toposort;
+})(ObjectType || (ObjectType = {}));
 //# sourceMappingURL=ObjectType.js.map

package/ast/ObjectUnionType.d.ts

@@ -0,0 +1,19 @@
+import type { TsFeature } from "../enums/index.js";
+import type { ObjectCompositeType } from "./ObjectCompositeType.js";
+/**
+ * A disjunction/union of object types, corresponding to an sh:xone on a node shape.
+ */
+export interface ObjectUnionType extends ObjectCompositeType {
+    /**
+     * Should generated code derived from this ObjectType be visible outside its module?
+     *
+     * Defaults to true.
+     */
+    readonly export: boolean;
+    readonly kind: "ObjectUnionType";
+    /**
+     * TypeScript features to generate.
+     */
+    readonly tsFeatures: Set<TsFeature>;
+}
+//# sourceMappingURL=ObjectUnionType.d.ts.map

package/ast/ObjectUnionType.js

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

package/ast/PlaceholderType.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A placeholder used temporarily when a type is being resolved.
+ */
+export interface PlaceholderType {
+    kind: "PlaceholderType";
+}
+//# sourceMappingURL=PlaceholderType.d.ts.map

package/ast/PlaceholderType.js

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

package/ast/SetType.d.ts

@@ -1,6 +1,6 @@
 import type { Type } from "./Type.js";
 /**
- * A set of items of a specific type.
+ * An unordered set of items of a specific type.
  *
  * This is a property with sh:maxCount != 1.
  */

package/ast/TermType.d.ts

@@ -0,0 +1,11 @@
+import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
+import type { NodeKind } from "@shaclmate/shacl-ast";
+import type { Maybe } from "purify-ts";
+export interface TermType<TermT extends BlankNode | Literal | NamedNode> {
+    readonly defaultValue: Maybe<TermT>;
+    readonly hasValues: readonly TermT[];
+    readonly in_: readonly TermT[];
+    readonly kind: "IdentifierType" | "LiteralType" | "TermType";
+    readonly nodeKinds: Set<NodeKind>;
+}
+//# sourceMappingURL=TermType.d.ts.map

package/ast/TermType.js

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

package/ast/Type.d.ts

@@ -1,9 +1,17 @@
+import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
 import type { IdentifierType } from "./IdentifierType.js";
 import type { IntersectionType } from "./IntersectionType.js";
+import type { ListType } from "./ListType.js";
 import type { LiteralType } from "./LiteralType.js";
+import type { ObjectIntersectionType } from "./ObjectIntersectionType.js";
 import type { ObjectType } from "./ObjectType.js";
-import type { OptionType } from "./OptionType";
-import type { SetType } from "./SetType";
+import type { ObjectUnionType } from "./ObjectUnionType.js";
+import type { OptionType } from "./OptionType.js";
+import type { PlaceholderType } from "./PlaceholderType.js";
+import type { SetType } from "./SetType.js";
+import type { TermType } from "./TermType.js";
 import type { UnionType } from "./UnionType.js";
-export type Type = IdentifierType | IntersectionType | LiteralType | ObjectType | OptionType | SetType | UnionType;
+export type Type = IdentifierType | IntersectionType | ListType | LiteralType | ObjectIntersectionType | ObjectType | ObjectUnionType | OptionType | PlaceholderType | SetType | (Omit<TermType<BlankNode | Literal | NamedNode>, "kind"> & {
+    readonly kind: "TermType";
+}) | UnionType;
 //# sourceMappingURL=Type.d.ts.map

package/ast/UnionType.d.ts

@@ -1,9 +1,9 @@
+import type { CompositeType } from "./CompositeType.js";
 import type { Type } from "./Type.js";
 /**
- * A disjunction/union of types, corresponding to an sh:or.
+ * A disjunction/union of types, corresponding to an sh:xone.
  */
-export interface UnionType {
+export interface UnionType extends CompositeType<Type> {
     readonly kind: "UnionType";
-    readonly memberTypes: readonly Type[];
 }
 //# sourceMappingURL=UnionType.d.ts.map

package/ast/index.d.ts

@@ -1,10 +1,13 @@
 export * from "./Ast.js";
 export * from "./IdentifierType.js";
-export * from "./IntersectionType";
+export * from "./IntersectionType.js";
+export * from "./ListType.js";
 export * from "./LiteralType.js";
-export * from "./MintingStrategy.js";
 export * from "./Name.js";
+export * from "./ObjectIntersectionType.js";
 export * from "./ObjectType.js";
-export * from "./UnionType";
+export * from "./ObjectUnionType.js";
+export * from "./UnionType.js";
+export * from "./TermType.js";
 export * from "./Type.js";
 //# sourceMappingURL=index.d.ts.map

package/ast/index.js

@@ -1,10 +1,13 @@
 export * from "./Ast.js";
 export * from "./IdentifierType.js";
-export * from "./IntersectionType";
+export * from "./IntersectionType.js";
+export * from "./ListType.js";
 export * from "./LiteralType.js";
-export * from "./MintingStrategy.js";
 export * from "./Name.js";
+export * from "./ObjectIntersectionType.js";
 export * from "./ObjectType.js";
-export * from "./UnionType";
+export * from "./ObjectUnionType.js";
+export * from "./UnionType.js";
+export * from "./TermType.js";
 export * from "./Type.js";
 //# sourceMappingURL=index.js.map

package/enums/MintingStrategy.d.ts

@@ -0,0 +1,5 @@
+/**
+ * TypeScript enum corresponding to shaclmate:mintingStrategy, for simpler manipulation.
+ */
+export type MintingStrategy = "sha256" | "uuidv4";
+//# sourceMappingURL=MintingStrategy.d.ts.map

package/enums/MintingStrategy.js

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

package/enums/PropertyVisibility.d.ts

@@ -0,0 +1,2 @@
+export type PropertyVisibility = "private" | "protected" | "public";
+//# sourceMappingURL=PropertyVisibility.d.ts.map

package/enums/PropertyVisibility.js

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

package/enums/TsFeature.d.ts

@@ -0,0 +1,5 @@
+export type TsFeature = "create" | "equals" | "fromJson" | "fromRdf" | "hash" | "jsonSchema" | "jsonUiSchema" | "sparql" | "toJson" | "toRdf";
+export declare namespace TsFeature {
+    const MEMBERS: readonly TsFeature[];
+}
+//# sourceMappingURL=TsFeature.d.ts.map

package/enums/TsFeature.js

@@ -0,0 +1,16 @@
+export var TsFeature;
+(function (TsFeature) {
+    TsFeature.MEMBERS = [
+        "create",
+        "equals",
+        "fromJson",
+        "fromRdf",
+        "hash",
+        "jsonSchema",
+        "jsonUiSchema",
+        "sparql",
+        "toJson",
+        "toRdf",
+    ];
+})(TsFeature || (TsFeature = {}));
+//# sourceMappingURL=TsFeature.js.map

package/enums/TsObjectDeclarationType.d.ts

@@ -0,0 +1,5 @@
+/**
+ * TypeScript enum corresponding to shaclmate:tsObjectDeclarationType, for simpler manipulation.
+ */
+export type TsObjectDeclarationType = "class" | "interface";
+//# sourceMappingURL=TsObjectDeclarationType.d.ts.map

package/enums/TsObjectDeclarationType.js

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

package/enums/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./MintingStrategy.js";
+export * from "./PropertyVisibility.js";
+export * from "./TsFeature.js";
+export * from "./TsObjectDeclarationType.js";
+//# sourceMappingURL=index.d.ts.map