@shaclmate/compiler 4.0.94 → 4.0.95

package/dist/ast/StructType.d.ts

@@ -1,7 +1,7 @@
 import type { BlankNode, NamedNode } from "@rdfjs/types";
 import { PropertyPath } from "@rdfx/resource";
 import type { NodeKind } from "@shaclmate/shacl-ast";
-import type { Maybe } from "purify-ts";
+import { Maybe } from "purify-ts";
 import { AbstractType } from "./AbstractType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
 import type { IdentifierType } from "./IdentifierType.js";
@@ -9,7 +9,6 @@ import type { IriType } from "./IriType.js";
 import { Type } from "./Type.js";
 export declare class StructType extends AbstractType {
     #private;
-    private fieldNames;
     /**
      * If true, the code for this StructType is defined externally and should not be generated.
      *
@@ -24,13 +23,16 @@ export declare class StructType extends AbstractType {
      */
     readonly fromRdfType: Maybe<NamedNode>;
     /**
-     * Identifier type.
+     * Identifier type, derived from the node shape's node kinds.
      */
     readonly identifierType: BlankNodeType | IdentifierType | IriType;
     /**
      * Type discriminant.
      */
     readonly kind = "Struct";
+    /**
+     * Fixed node kinds.
+     */
     readonly nodeKinds: ReadonlySet<NodeKind>;
     /**
      * Was this type synthesized or did it come from SHACL?
@@ -61,35 +63,62 @@ export declare class StructType extends AbstractType {
         tsImports: readonly string[];
     } & ConstructorParameters<typeof AbstractType>[0]);
     get fields(): readonly StructType.Field[];
+    get identifierField(): Maybe<StructType.IdentifierField>;
     get recursive(): boolean;
-    addFields(...fields: readonly StructType.Field[]): void;
+    addField(field: StructType.Field): void;
     equals(other: StructType): boolean;
     sortFields(): void;
     toJSON(): {
         fromRdfType: NamedNode<string> | undefined;
-        identifierType: {
-            hasValues: readonly NamedNode<string>[] | undefined;
-            in: readonly NamedNode<string>[] | undefined;
-            nodeKinds: NodeKind[];
-            comment: string | undefined;
-            kind: string;
-            label: string | undefined;
-            name: string | undefined;
-            recursive: boolean | undefined;
-            shapeIdentifier: BlankNode | NamedNode<string>;
-        };
         synthetic: boolean | undefined;
         toRdfTypes: readonly NamedNode<string>[] | undefined;
-        comment: string | undefined;
         kind: string;
-        label: string | undefined;
         name: string | undefined;
         recursive: boolean | undefined;
         shapeIdentifier: BlankNode | NamedNode<string>;
+        comment: string | undefined;
+        label: string | undefined;
     };
 }
 export declare namespace StructType {
-    class Field {
+    abstract class AbstractField {
+        /**
+         * Type discriminant.
+         */
+        abstract readonly kind: "Identifier" | "Shacl";
+        /**
+         * Relative order of this field among the fields of the struct.
+         */
+        abstract readonly order: number;
+        /**
+         * Does the field directly or indirectly reference the StructType itself?
+         */
+        abstract readonly recursive: boolean;
+        /**
+         * StructType this field belongs to.
+         */
+        readonly structType: StructType;
+        constructor({ structType }: {
+            structType: StructType;
+        });
+        toJSON(): {
+            kind: "Identifier" | "Shacl";
+        };
+        toString(): string;
+    }
+    export class IdentifierField extends AbstractField {
+        readonly kind = "Identifier";
+        readonly order = 0;
+        readonly recursive = false;
+        /**
+         * Identifier type.
+         */
+        readonly type: BlankNodeType | IdentifierType | IriType;
+        constructor({ type, ...superParameters }: {
+            type: BlankNodeType | IdentifierType | IriType;
+        } & ConstructorParameters<typeof AbstractField>[0]);
+    }
+    export class ShaclField extends AbstractField {
         /**
          * Documentation comment from rdfs:comment.
          */
@@ -102,10 +131,18 @@ export declare namespace StructType {
          * Should the field and its value be displayed in a toString()-type representation?
          */
         readonly display: boolean;
+        /**
+         * Type discriminant.
+         */
+        readonly kind = "Shacl";
         /**
          * Human-readable label from rdfs:label.
          */
         readonly label: Maybe<string>;
+        /**
+         * Minimum cardinality of this field, derived from sh:minCount.
+         */
+        readonly minCount: bigint;
         /**
          * The field should be mutable in generated code i.e., it should be re-assignable. The field value may or may
          * not be mutable.
@@ -127,31 +164,24 @@ export declare namespace StructType {
          * Identifier of the field shape.
          */
         readonly shapeIdentifier: BlankNode | NamedNode;
-        /**
-         * StructType this field belongs to.
-         */
-        readonly structType: StructType;
         /**
          * Type of this field.
          */
         readonly type: Type;
-        constructor({ comment, description, display, label, mutable, name, order, path, shapeIdentifier, structType, type, }: {
+        constructor({ comment, description, display, label, minCount, mutable, name, order, path, shapeIdentifier, type, ...superParameters }: {
             comment: Maybe<string>;
             description: Maybe<string>;
             display: boolean;
             label: Maybe<string>;
+            minCount: bigint;
             mutable: boolean;
             name: string;
             order: number;
             path: PropertyPath;
             shapeIdentifier: BlankNode | NamedNode;
-            structType: StructType;
             type: Type;
-        });
-        equals(other: Field): boolean;
-        /**
-         * Does the field directly or indirectly reference the StructType itself?
-         */
+        } & ConstructorParameters<typeof AbstractField>[0]);
+        equals(other: ShaclField): boolean;
         get recursive(): boolean;
         toJSON(): {
             comment: string | undefined;
@@ -164,15 +194,17 @@ export declare namespace StructType {
             recursive: boolean | undefined;
             shapeIdentifier: BlankNode | NamedNode<string>;
             type: {
-                comment: string | undefined;
                 kind: string;
-                label: string | undefined;
                 name: string | undefined;
                 recursive: boolean | undefined;
                 shapeIdentifier: BlankNode | NamedNode<string>;
+                comment: string | undefined;
+                label: string | undefined;
             };
+            kind: "Identifier" | "Shacl";
         };
-        toString(): string;
     }
+    export type Field = IdentifierField | ShaclField;
+    export {};
 }
 //# sourceMappingURL=StructType.d.ts.map

package/dist/ast/StructType.js

@@ -5,6 +5,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { PropertyPath } from "@rdfx/resource";
+import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractType } from "./AbstractType.js";
@@ -17,7 +18,6 @@ export class StructType extends AbstractType {
      * Mutable to support cycle-handling logic in the compiler.
      */
     #fields = [];
-    fieldNames = new Set();
     /**
      * If true, the code for this StructType is defined externally and should not be generated.
      *
@@ -32,13 +32,16 @@ export class StructType extends AbstractType {
      */
     fromRdfType;
     /**
-     * Identifier type.
+     * Identifier type, derived from the node shape's node kinds.
      */
     identifierType;
     /**
      * Type discriminant.
      */
     kind = "Struct";
+    /**
+     * Fixed node kinds.
+     */
     nodeKinds = nodeKinds;
     /**
      * Was this type synthesized or did it come from SHACL?
@@ -72,16 +75,15 @@ export class StructType extends AbstractType {
     get fields() {
         return this.#fields;
     }
+    get identifierField() {
+        return Maybe.fromNullable(this.fields.find((field) => field.kind === "Identifier"));
+    }
     get recursive() {
         return this.fields.some((field) => field.recursive);
     }
-    addFields(...fields) {
-        for (const field of fields) {
-            invariant(Object.is(field.structType, this), "field has unexpected .structType");
-            invariant(!this.fieldNames.has(field.name), `${field.structType.shapeIdentifier}: duplicate field name: ${field.name}`);
-            this.#fields.push(field);
-            this.fieldNames.add(field.name);
-        }
+    addField(field) {
+        invariant(Object.is(field.structType, this), "field has unexpected .structType");
+        this.#fields.push(field);
     }
     equals(other) {
         // Don't recurse
@@ -102,7 +104,6 @@ export class StructType extends AbstractType {
         return {
             ...super.toJSON(),
             fromRdfType: this.fromRdfType.extract(),
-            identifierType: this.identifierType.toJSON(),
             synthetic: this.synthetic ? true : undefined,
             toRdfTypes: this.toRdfTypes.length > 0 ? this.toRdfTypes : undefined,
         };
@@ -110,7 +111,38 @@ export class StructType extends AbstractType {
 }
 const nodeKinds = new Set(["BlankNode", "IRI"]);
 (function (StructType) {
-    class Field {
+    class AbstractField {
+        /**
+         * StructType this field belongs to.
+         */
+        structType;
+        constructor({ structType }) {
+            this.structType = structType;
+        }
+        toJSON() {
+            return {
+                kind: this.kind,
+            };
+        }
+        toString() {
+            return JSON.stringify(this.toJSON());
+        }
+    }
+    class IdentifierField extends AbstractField {
+        kind = "Identifier";
+        order = 0;
+        recursive = false;
+        /**
+         * Identifier type.
+         */
+        type;
+        constructor({ type, ...superParameters }) {
+            super(superParameters);
+            this.type = type;
+        }
+    }
+    StructType.IdentifierField = IdentifierField;
+    class ShaclField extends AbstractField {
         /**
          * Documentation comment from rdfs:comment.
          */
@@ -123,10 +155,18 @@ const nodeKinds = new Set(["BlankNode", "IRI"]);
          * Should the field and its value be displayed in a toString()-type representation?
          */
         display;
+        /**
+         * Type discriminant.
+         */
+        kind = "Shacl";
         /**
          * Human-readable label from rdfs:label.
          */
         label;
+        /**
+         * Minimum cardinality of this field, derived from sh:minCount.
+         */
+        minCount;
         /**
          * The field should be mutable in generated code i.e., it should be re-assignable. The field value may or may
          * not be mutable.
@@ -148,22 +188,19 @@ const nodeKinds = new Set(["BlankNode", "IRI"]);
          * Identifier of the field shape.
          */
         shapeIdentifier;
-        /**
-         * StructType this field belongs to.
-         */
-        structType;
         /**
          * Type of this field.
          */
         type;
-        constructor({ comment, description, display, label, mutable, name, order, path, shapeIdentifier, structType, type, }) {
+        constructor({ comment, description, display, label, minCount, mutable, name, order, path, shapeIdentifier, type, ...superParameters }) {
+            super(superParameters);
             this.comment = comment;
             this.description = description;
             this.display = display;
             this.label = label;
+            this.minCount = minCount;
             this.mutable = mutable;
             this.name = name;
-            this.structType = structType;
             this.order = order;
             this.path = path;
             this.shapeIdentifier = shapeIdentifier;
@@ -172,9 +209,6 @@ const nodeKinds = new Set(["BlankNode", "IRI"]);
         equals(other) {
             return this.shapeIdentifier.equals(other.shapeIdentifier);
         }
-        /**
-         * Does the field directly or indirectly reference the StructType itself?
-         */
         get recursive() {
             const DEBUG = false;
             const rootField = this;
@@ -250,10 +284,11 @@ const nodeKinds = new Set(["BlankNode", "IRI"]);
                             process.stderr.write(`recurse into ${currentFieldType}`);
                         }
                         for (const field of currentFieldType.fields) {
-                            if (helper(stack.concat({
-                                structType: currentFieldType,
-                                field,
-                            }))) {
+                            if (field.kind === "Shacl" &&
+                                helper(stack.concat({
+                                    structType: currentFieldType,
+                                    field,
+                                }))) {
                                 return true;
                             }
                         }
@@ -290,6 +325,7 @@ const nodeKinds = new Set(["BlankNode", "IRI"]);
         }
         toJSON() {
             return {
+                ...super.toJSON(),
                 comment: this.comment.extract(),
                 description: this.description.extract(),
                 label: this.label.extract(),
@@ -302,13 +338,10 @@ const nodeKinds = new Set(["BlankNode", "IRI"]);
                 type: this.type.toJSON(),
             };
         }
-        toString() {
-            return JSON.stringify(this.toJSON());
-        }
     }
     __decorate([
         Memoize()
-    ], Field.prototype, "recursive", null);
-    StructType.Field = Field;
+    ], ShaclField.prototype, "recursive", null);
+    StructType.ShaclField = ShaclField;
 })(StructType || (StructType = {}));
 //# sourceMappingURL=StructType.js.map

package/dist/ast/index.d.ts

@@ -10,7 +10,9 @@ export * from "./LazySetType.js";
 export * from "./LazyType.js";
 export * from "./ListType.js";
 export * from "./LiteralType.js";
+export * from "./Operation.js";
 export * from "./OptionType.js";
+export * from "./Service.js";
 export * from "./SetType.js";
 export * from "./StructCompoundType.js";
 export * from "./StructDiscriminatedUnionType.js";

package/dist/ast/index.js

@@ -10,7 +10,9 @@ export * from "./LazySetType.js";
 export * from "./LazyType.js";
 export * from "./ListType.js";
 export * from "./LiteralType.js";
+export * from "./Operation.js";
 export * from "./OptionType.js";
+export * from "./Service.js";
 export * from "./SetType.js";
 export * from "./StructCompoundType.js";
 export * from "./StructDiscriminatedUnionType.js";

package/dist/generators/transformAstToLabeledPropertyGraph.js

@@ -9,24 +9,27 @@ export function transformAstToLabeledPropertyGraph(ast) {
             const properties = {
                 name: { type: "string", value: typeName(namedType) },
             };
-            for (const namedObjectTypeProperty of namedStructType.fields) {
+            for (const namedStructTypeField of namedStructType.fields) {
+                if (namedStructTypeField.kind !== "Shacl") {
+                    continue;
+                }
                 let itemType;
-                switch (namedObjectTypeProperty.type.kind) {
+                switch (namedStructTypeField.type.kind) {
                     case "DefaultValue":
                     case "List":
                     case "Option":
                     case "Set":
-                        itemType = namedObjectTypeProperty.type.itemType;
+                        itemType = namedStructTypeField.type.itemType;
                         break;
                     case "Lazy":
-                        itemType = namedObjectTypeProperty.type.resolveType;
+                        itemType = namedStructTypeField.type.resolveType;
                         break;
                     case "LazyOption":
                     case "LazySet":
-                        itemType = namedObjectTypeProperty.type.resolveType.itemType;
+                        itemType = namedStructTypeField.type.resolveType.itemType;
                         break;
                     default:
-                        itemType = namedObjectTypeProperty.type;
+                        itemType = namedStructTypeField.type;
                         break;
                 }
                 switch (itemType.kind) {
@@ -35,8 +38,8 @@ export function transformAstToLabeledPropertyGraph(ast) {
                     case "DiscriminatedUnion":
                         if (itemType.name.isJust()) {
                             relationships.push({
-                                id: namedObjectTypeProperty.shapeIdentifier.toString(),
-                                label: Maybe.of(namedObjectTypeProperty.name),
+                                id: namedStructTypeField.shapeIdentifier.toString(),
+                                label: Maybe.of(namedStructTypeField.name),
                                 properties: {},
                                 sourceNodeId: id,
                                 targetNodeId: typeId(itemType),
@@ -44,9 +47,9 @@ export function transformAstToLabeledPropertyGraph(ast) {
                         }
                         break;
                     default:
-                        properties[namedObjectTypeProperty.name] = {
+                        properties[namedStructTypeField.name] = {
                             type: "string",
-                            value: namedObjectTypeProperty.toString(),
+                            value: namedStructTypeField.toString(),
                         };
                 }
             }

package/dist/generators/ts/AbstractCallable.d.ts

@@ -0,0 +1,20 @@
+import type { Code } from "./ts-poet-wrapper.js";
+/**
+ * Abstract base class for callables.
+ */
+export declare abstract class AbstractCallable {
+    /**
+     * Code to use this callable as a callee or reference it (in composition for example).
+     *
+     * If the callable has an optional type annotation, it will be included in the returned code.
+     */
+    abstract readonly annotatedUsage: Code;
+    /**
+     * Code to use this callable as a callee or reference it (in composition, for example).
+     *
+     * If the callable has an optional type annotation, it won't be included in the returned code.
+     */
+    abstract readonly unannotatedUsage: Code;
+    toString(): string;
+}
+//# sourceMappingURL=AbstractCallable.d.ts.map

package/dist/generators/ts/AbstractCallable.js

@@ -0,0 +1,9 @@
+/**
+ * Abstract base class for callables.
+ */
+export class AbstractCallable {
+    toString() {
+        throw new Error("should never call toString on a Callable");
+    }
+}
+//# sourceMappingURL=AbstractCallable.js.map

package/dist/generators/ts/AbstractCollectionType.d.ts

@@ -1,37 +1,35 @@
 import { Maybe } from "purify-ts";
 import { AbstractContainerType } from "./AbstractContainerType.js";
+import type { Callable } from "./Callable.js";
 import { type Code } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class for ListType and SetType.
  */
 export declare abstract class AbstractCollectionType<ItemTypeT extends AbstractCollectionType.ItemType> extends AbstractContainerType<ItemTypeT> {
     protected readonly _mutable: boolean;
-    readonly discriminantProperty: Maybe<AbstractContainerType.DiscriminantProperty>;
     readonly graphqlArgs: AbstractContainerType<ItemTypeT>["graphqlArgs"];
     constructor({ mutable, ...superParameters }: {
         mutable: boolean;
     } & ConstructorParameters<typeof AbstractContainerType<ItemTypeT>>[0]);
-    get equalsFunction(): Code;
-    get filterFunction(): Code;
+    get equalsFunction(): Callable;
+    get filterFunction(): Callable;
     get filterType(): Code;
     get graphqlType(): AbstractContainerType.GraphqlType;
-    get hashFunction(): Code;
+    get hashFunction(): Callable;
     get mutable(): boolean;
     get schemaType(): Code;
-    get validationFunction(): Maybe<Code>;
+    get validationFunction(): Maybe<Callable>;
     protected get inlineExpression(): Code;
     graphqlResolveExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["graphqlResolveExpression"]>[0]): Code;
-    jsonUiSchemaElement(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonUiSchemaElement"]>[0]): Maybe<Code>;
-    toJsonExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["toJsonExpression"]>[0]): Code;
+    toLoggableExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["toLoggableExpression"]>[0]): Code;
 }
 export declare namespace AbstractCollectionType {
     type ConversionFunction = AbstractContainerType.ConversionFunction;
-    type DiscriminantProperty = AbstractContainerType.DiscriminantProperty;
+    type DiscriminatedType = AbstractContainerType.DiscriminatedType;
     const GraphqlType: typeof import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
     type GraphqlType = AbstractContainerType.GraphqlType;
     const isItemType: typeof AbstractContainerType.isItemType;
     type ItemType = AbstractContainerType.ItemType;
-    const JsonType: typeof import("./_AbstractType/AbstractType_JsonType.js").AbstractType_JsonType;
     type JsonType = AbstractContainerType.JsonType;
 }
 //# sourceMappingURL=AbstractCollectionType.d.ts.map

package/dist/generators/ts/AbstractCollectionType.js

@@ -7,23 +7,25 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractContainerType } from "./AbstractContainerType.js";
+import { InlineCallable } from "./InlineCallable.js";
 import { code } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class for ListType and SetType.
  */
 export class AbstractCollectionType extends AbstractContainerType {
     _mutable;
-    discriminantProperty = Maybe.empty();
     graphqlArgs = Maybe.empty();
     constructor({ mutable, ...superParameters }) {
         super(superParameters);
         this._mutable = mutable;
     }
     get equalsFunction() {
-        return code `((left, right) => ${this.reusables.snippets.arrayEquals}(left, right, ${this.itemType.equalsFunction}))`;
+        return new InlineCallable(code `((left, right) => ${this.reusables.snippets.arrayEquals}(left, right, ${this.itemType.equalsFunction.unannotatedUsage}))`, {
+            type: code `${this.reusables.snippets.EqualsFunction}<${this.expression}>`,
+        });
     }
     get filterFunction() {
-        return code `${this.reusables.snippets.filterArray}<${this.itemType.expression}, ${this.itemType.filterType}>(${this.itemType.filterFunction})`;
+        return new InlineCallable(code `${this.reusables.snippets.filterArray}<${this.itemType.expression}, ${this.itemType.filterType}>(${this.itemType.filterFunction.unannotatedUsage})`);
     }
     get filterType() {
         return code `${this.reusables.snippets.CollectionFilter}<${this.itemType.filterType}>`;
@@ -32,7 +34,7 @@ export class AbstractCollectionType extends AbstractContainerType {
         return new AbstractContainerType.GraphqlType(code `new ${this.reusables.imports.GraphQLList}(${this.itemType.graphqlType.expression})`, this.reusables);
     }
     get hashFunction() {
-        return code `${this.reusables.snippets.hashArray}(${this.itemType.hashFunction})`;
+        return new InlineCallable(code `${this.reusables.snippets.hashArray}(${this.itemType.hashFunction.annotatedUsage})`);
     }
     get mutable() {
         return this._mutable || this.itemType.mutable;
@@ -41,7 +43,9 @@ export class AbstractCollectionType extends AbstractContainerType {
         return code `${this.reusables.snippets.CollectionSchema}<${this.itemType.schemaType}>`;
     }
     get validationFunction() {
-        return Maybe.of(code `${this._mutable ? this.reusables.snippets.validateMutableArray : this.reusables.snippets.validateArray}(${this.itemType.validationFunction.orDefault(this.itemValidationFunctionDefault)})`);
+        return Maybe.of(new InlineCallable(code `${this._mutable ? this.reusables.snippets.validateMutableArray : this.reusables.snippets.validateArray}(${this.itemType.validationFunction
+            .map((_) => _.unannotatedUsage)
+            .orDefault(this.itemValidationFunctionDefault.unannotatedUsage)})`));
     }
     get inlineExpression() {
         return code `${!this._mutable ? "readonly " : ""}(${this.itemType.expression})[]`;
@@ -49,11 +53,8 @@ export class AbstractCollectionType extends AbstractContainerType {
     graphqlResolveExpression({ variables, }) {
         return variables.value;
     }
-    jsonUiSchemaElement(parameters) {
-        return this.itemType.jsonUiSchemaElement(parameters);
-    }
-    toJsonExpression({ variables, }) {
-        return code `${variables.value}.map(item => (${this.itemType.toJsonExpression({ variables: { value: code `item` } })}))`;
+    toLoggableExpression({ variables, }) {
+        return code `${variables.value}.map(item => (${this.itemType.toLoggableExpression({ variables: { value: code `item` } })}))`;
     }
 }
 __decorate([
@@ -83,6 +84,5 @@ __decorate([
 (function (AbstractCollectionType) {
     AbstractCollectionType.GraphqlType = AbstractContainerType.GraphqlType;
     AbstractCollectionType.isItemType = AbstractContainerType.isItemType;
-    AbstractCollectionType.JsonType = AbstractContainerType.JsonType;
 })(AbstractCollectionType || (AbstractCollectionType = {}));
 //# sourceMappingURL=AbstractCollectionType.js.map

package/dist/generators/ts/AbstractCompoundType.d.ts

@@ -0,0 +1,18 @@
+import { AbstractStructuredType } from "./AbstractStructuredType.js";
+import type { Type } from "./Type.js";
+export declare abstract class AbstractCompoundType<MemberT extends {
+    type: MemberTypeT;
+}, MemberTypeT extends Type> extends AbstractStructuredType {
+    abstract readonly members: readonly MemberT[];
+    get mutable(): boolean;
+    get referencesNamedType(): boolean;
+    get toRdfResourceValueTypes(): AbstractStructuredType["toRdfResourceValueTypes"];
+}
+export declare namespace AbstractCompoundType {
+    type ConversionFunction = AbstractStructuredType.ConversionFunction;
+    type DiscriminatedType = AbstractStructuredType.DiscriminatedType;
+    type GraphqlType = AbstractStructuredType.GraphqlType;
+    type JsonType = AbstractStructuredType.JsonType;
+    type JsType = AbstractStructuredType.JsType;
+}
+//# sourceMappingURL=AbstractCompoundType.d.ts.map

package/dist/generators/ts/AbstractCompoundType.js

@@ -0,0 +1,33 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Memoize } from "typescript-memoize";
+import { AbstractStructuredType } from "./AbstractStructuredType.js";
+export class AbstractCompoundType extends AbstractStructuredType {
+    get mutable() {
+        return this.members.some((member) => member.type.mutable);
+    }
+    get referencesNamedType() {
+        return (this.name.isJust() ||
+            this.members.some((member) => member.type.referencesNamedType));
+    }
+    get toRdfResourceValueTypes() {
+        const set = new Set();
+        for (const member of this.members) {
+            for (const value of member.type.toRdfResourceValueTypes) {
+                set.add(value);
+            }
+        }
+        return set;
+    }
+}
+__decorate([
+    Memoize()
+], AbstractCompoundType.prototype, "mutable", null);
+__decorate([
+    Memoize()
+], AbstractCompoundType.prototype, "toRdfResourceValueTypes", null);
+//# sourceMappingURL=AbstractCompoundType.js.map