@shaclmate/compiler 2.0.13 → 2.0.14

package/input/Ontology.d.ts

@@ -0,0 +1,13 @@
+import { Ontology as OwlOntology } from "@shaclmate/shacl-ast";
+import type { Maybe } from "purify-ts";
+import type { TsFeature, TsObjectDeclarationType } from "../enums/index.js";
+import type * as generated from "./generated.js";
+export declare class Ontology extends OwlOntology {
+    private readonly generatedShaclmateOntology;
+    constructor(generatedShaclmateOntology: generated.ShaclmateOntology);
+    get tsDataFactoryVariable(): Maybe<string>;
+    get tsFeatures(): Maybe<Set<TsFeature>>;
+    get tsImports(): readonly string[];
+    get tsObjectDeclarationType(): Maybe<TsObjectDeclarationType>;
+}
+//# sourceMappingURL=Ontology.d.ts.map

package/input/Ontology.js

@@ -0,0 +1,30 @@
+import { Ontology as OwlOntology } from "@shaclmate/shacl-ast";
+import { tsFeatures } from "./tsFeatures.js";
+export class Ontology extends OwlOntology {
+    constructor(generatedShaclmateOntology) {
+        super(generatedShaclmateOntology);
+        this.generatedShaclmateOntology = generatedShaclmateOntology;
+    }
+    get tsDataFactoryVariable() {
+        return this.generatedShaclmateOntology.tsDataFactoryVariable;
+    }
+    get tsFeatures() {
+        return tsFeatures(this.generatedShaclmateOntology);
+    }
+    get tsImports() {
+        return this.generatedShaclmateOntology.tsImports;
+    }
+    get tsObjectDeclarationType() {
+        return this.generatedShaclmateOntology.tsObjectDeclarationType.map((iri) => {
+            switch (iri.value) {
+                case "http://minorg.github.io/shaclmate/ns#_TsObjectDeclarationType_Class":
+                    return "class";
+                case "http://minorg.github.io/shaclmate/ns#_TsObjectDeclarationType_Interface":
+                    return "interface";
+                default:
+                    throw new RangeError(iri.value);
+            }
+        });
+    }
+}
+//# sourceMappingURL=Ontology.js.map

package/input/PropertyShape.d.ts

@@ -0,0 +1,15 @@
+import { PropertyShape as ShaclCorePropertyShape } from "@shaclmate/shacl-ast";
+import { Maybe } from "purify-ts";
+import type { PropertyVisibility } from "../enums/index.js";
+import type { Shape } from "./Shape.js";
+import type * as generated from "./generated.js";
+import type { NodeShape, Ontology, PropertyGroup, ShapesGraph } from "./index.js";
+export declare class PropertyShape extends ShaclCorePropertyShape<NodeShape, Ontology, PropertyGroup, any, Shape> {
+    private readonly generatedShaclmatePropertyShape;
+    constructor(generatedShaclmatePropertyShape: generated.ShaclmatePropertyShape, shapesGraph: ShapesGraph);
+    get extern(): Maybe<boolean>;
+    get mutable(): Maybe<boolean>;
+    get shaclmateName(): Maybe<string>;
+    get visibility(): PropertyVisibility;
+}
+//# sourceMappingURL=PropertyShape.d.ts.map

package/input/PropertyShape.js

@@ -0,0 +1,34 @@
+import { PropertyShape as ShaclCorePropertyShape } from "@shaclmate/shacl-ast";
+import { Maybe } from "purify-ts";
+export class PropertyShape extends ShaclCorePropertyShape {
+    constructor(generatedShaclmatePropertyShape, shapesGraph) {
+        super({ ...generatedShaclmatePropertyShape, uniqueLang: Maybe.empty() }, shapesGraph);
+        this.generatedShaclmatePropertyShape = generatedShaclmatePropertyShape;
+    }
+    get extern() {
+        return this.generatedShaclmatePropertyShape.extern;
+    }
+    get mutable() {
+        return this.generatedShaclmatePropertyShape.mutable;
+    }
+    get shaclmateName() {
+        return this.generatedShaclmatePropertyShape.name;
+    }
+    get visibility() {
+        return this.generatedShaclmatePropertyShape.visibility
+            .map((iri) => {
+            switch (iri.value) {
+                case "http://minorg.github.io/shaclmate/ns#_Visibility_Private":
+                    return "private";
+                case "http://minorg.github.io/shaclmate/ns#_Visibility_Protected":
+                    return "protected";
+                case "http://minorg.github.io/shaclmate/ns#_Visibility_Public":
+                    return "public";
+                default:
+                    throw new RangeError(iri.value);
+            }
+        })
+            .orDefault("public");
+    }
+}
+//# sourceMappingURL=PropertyShape.js.map

package/input/Shape.d.ts

@@ -0,0 +1,4 @@
+import type { NodeShape } from "./NodeShape.js";
+import type { PropertyShape } from "./PropertyShape.js";
+export type Shape = NodeShape | PropertyShape;
+//# sourceMappingURL=Shape.d.ts.map

package/input/Shape.js

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

package/input/ShapesGraph.d.ts

@@ -0,0 +1,9 @@
+import type { DatasetCore } from "@rdfjs/types";
+import { RdfjsShapesGraph } from "@shaclmate/shacl-ast";
+import { NodeShape, Ontology, PropertyGroup, PropertyShape, type Shape } from "./index.js";
+export declare class ShapesGraph extends RdfjsShapesGraph<NodeShape, Ontology, PropertyGroup, PropertyShape, Shape> {
+    constructor({ dataset }: {
+        dataset: DatasetCore;
+    });
+}
+//# sourceMappingURL=ShapesGraph.d.ts.map

package/input/ShapesGraph.js

@@ -0,0 +1,50 @@
+import { RdfjsShapesGraph } from "@shaclmate/shacl-ast";
+import { owl, rdf, rdfs } from "@tpluscode/rdf-ns-builders";
+import { ancestorClassIris } from "./ancestorClassIris.js";
+import { descendantClassIris } from "./descendantClassIris.js";
+import * as generated from "./generated.js";
+import { NodeShape, Ontology, PropertyGroup, PropertyShape, } from "./index.js";
+export class ShapesGraph extends RdfjsShapesGraph {
+    constructor({ dataset }) {
+        super({
+            dataset,
+            factory: {
+                nodeShapeFromRdf({ resource, shapesGraph, }) {
+                    return generated.ShaclmateNodeShape.fromRdf({
+                        ignoreRdfType: true,
+                        resource,
+                    }).map((generatedShape) => new NodeShape({
+                        ancestorClassIris: ancestorClassIris(resource, Number.MAX_SAFE_INTEGER),
+                        childClassIris: descendantClassIris(resource, 1),
+                        descendantClassIris: descendantClassIris(resource, Number.MAX_SAFE_INTEGER),
+                        generatedShaclmateNodeShape: generatedShape,
+                        isClass: resource.isInstanceOf(owl.Class) ||
+                            resource.isInstanceOf(rdfs.Class),
+                        isList: resource.isSubClassOf(rdf.List),
+                        parentClassIris: ancestorClassIris(resource, 1),
+                        shapesGraph,
+                    }));
+                },
+                ontologyFromRdf({ resource, }) {
+                    return generated.ShaclmateOntology.fromRdf({
+                        ignoreRdfType: true,
+                        resource,
+                    }).map((generatedOntology) => new Ontology(generatedOntology));
+                },
+                propertyGroupFromRdf({ resource, }) {
+                    return generated.ShaclCorePropertyGroup.fromRdf({
+                        ignoreRdfType: true,
+                        resource,
+                    }).map((generatedPropertyGroup) => new PropertyGroup(generatedPropertyGroup));
+                },
+                propertyShapeFromRdf({ resource, shapesGraph, }) {
+                    return generated.ShaclmatePropertyShape.fromRdf({
+                        ignoreRdfType: true,
+                        resource,
+                    }).map((generatedShape) => new PropertyShape(generatedShape, shapesGraph));
+                },
+            },
+        });
+    }
+}
+//# sourceMappingURL=ShapesGraph.js.map

package/input/ancestorClassIris.d.ts

@@ -0,0 +1,4 @@
+import type { NamedNode } from "@rdfjs/types";
+import type { Resource } from "rdfjs-resource";
+export declare function ancestorClassIris(classResource: Resource, maxDepth: number): readonly NamedNode[];
+//# sourceMappingURL=ancestorClassIris.d.ts.map

package/input/ancestorClassIris.js

@@ -0,0 +1,21 @@
+import TermSet from "@rdfjs/term-set";
+import { rdfs } from "@tpluscode/rdf-ns-builders";
+export function ancestorClassIris(classResource, maxDepth) {
+    const ancestorClassIris = new TermSet();
+    function ancestorClassIrisRecursive(classResource, depth) {
+        for (const parentClassValue of classResource.values(rdfs.subClassOf)) {
+            parentClassValue.toNamedResource().ifRight((parentClassResource) => {
+                if (ancestorClassIris.has(parentClassResource.identifier)) {
+                    return;
+                }
+                ancestorClassIris.add(parentClassResource.identifier);
+                if (depth < maxDepth) {
+                    ancestorClassIrisRecursive(parentClassResource, depth + 1);
+                }
+            });
+        }
+    }
+    ancestorClassIrisRecursive(classResource, 1);
+    return [...ancestorClassIris];
+}
+//# sourceMappingURL=ancestorClassIris.js.map

package/input/descendantClassIris.d.ts

@@ -0,0 +1,4 @@
+import type { NamedNode } from "@rdfjs/types";
+import type { Resource } from "rdfjs-resource";
+export declare function descendantClassIris(classResource: Resource, maxDepth: number): readonly NamedNode[];
+//# sourceMappingURL=descendantClassIris.d.ts.map

package/input/descendantClassIris.js

@@ -0,0 +1,21 @@
+import TermSet from "@rdfjs/term-set";
+import { rdfs } from "@tpluscode/rdf-ns-builders";
+export function descendantClassIris(classResource, maxDepth) {
+    const descendantClassIris = new TermSet();
+    function descendantClassIrisRecursive(classResource, depth) {
+        for (const childClassValue of classResource.valuesOf(rdfs.subClassOf)) {
+            childClassValue.toNamedResource().ifRight((childClassResource) => {
+                if (descendantClassIris.has(childClassResource.identifier)) {
+                    return;
+                }
+                descendantClassIris.add(childClassResource.identifier);
+                if (depth < maxDepth) {
+                    descendantClassIrisRecursive(childClassResource, depth + 1);
+                }
+            });
+        }
+    }
+    descendantClassIrisRecursive(classResource, 1);
+    return [...descendantClassIris];
+}
+//# sourceMappingURL=descendantClassIris.js.map

package/input/generated.d.ts

@@ -0,0 +1,274 @@
+import type * as rdfjs from "@rdfjs/types";
+import { PropertyPath } from "@shaclmate/shacl-ast/PropertyPath.js";
+import * as purify from "purify-ts";
+import type * as purifyHelpers from "purify-ts-helpers";
+import * as rdfjsResource from "rdfjs-resource";
+export interface BaseShaclCoreShape {
+    readonly and: readonly (readonly (rdfjs.BlankNode | rdfjs.NamedNode)[])[];
+    readonly classes: readonly rdfjs.NamedNode[];
+    readonly comments: readonly rdfjs.Literal[];
+    readonly datatype: purify.Maybe<rdfjs.NamedNode>;
+    readonly deactivated: purify.Maybe<boolean>;
+    readonly flags: readonly string[];
+    readonly hasValues: readonly (rdfjs.BlankNode | rdfjs.NamedNode | rdfjs.Literal)[];
+    readonly identifier: rdfjs.BlankNode | rdfjs.NamedNode;
+    readonly in_: purify.Maybe<readonly (rdfjs.BlankNode | rdfjs.NamedNode | rdfjs.Literal)[]>;
+    readonly isDefinedBy: purify.Maybe<rdfjs.BlankNode | rdfjs.NamedNode>;
+    readonly labels: readonly rdfjs.Literal[];
+    readonly languageIn: purify.Maybe<readonly string[]>;
+    readonly maxCount: purify.Maybe<number>;
+    readonly maxExclusive: purify.Maybe<rdfjs.Literal>;
+    readonly maxInclusive: purify.Maybe<rdfjs.Literal>;
+    readonly maxLength: purify.Maybe<number>;
+    readonly minCount: purify.Maybe<number>;
+    readonly minExclusive: purify.Maybe<rdfjs.Literal>;
+    readonly minInclusive: purify.Maybe<rdfjs.Literal>;
+    readonly minLength: purify.Maybe<number>;
+    readonly nodeKind: purify.Maybe<rdfjs.NamedNode<"http://www.w3.org/ns/shacl#BlankNode" | "http://www.w3.org/ns/shacl#BlankNodeOrIRI" | "http://www.w3.org/ns/shacl#BlankNodeOrLiteral" | "http://www.w3.org/ns/shacl#IRI" | "http://www.w3.org/ns/shacl#IRIOrLiteral" | "http://www.w3.org/ns/shacl#Literal">>;
+    readonly nodes: readonly (rdfjs.BlankNode | rdfjs.NamedNode)[];
+    readonly not: readonly (rdfjs.BlankNode | rdfjs.NamedNode)[];
+    readonly or: readonly (readonly (rdfjs.BlankNode | rdfjs.NamedNode)[])[];
+    readonly patterns: readonly string[];
+    readonly type: "ShaclCoreNodeShape" | "ShaclCorePropertyShape" | "ShaclmateNodeShape" | "ShaclmatePropertyShape";
+    readonly xone: readonly (readonly (rdfjs.BlankNode | rdfjs.NamedNode)[])[];
+}
+export declare namespace BaseShaclCoreShape {
+    function propertiesFromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, ..._context }: {
+        [_index: string]: any;
+        ignoreRdfType?: boolean;
+        languageIn?: readonly string[];
+        resource: rdfjsResource.Resource;
+    }): purify.Either<rdfjsResource.Resource.ValueError, {
+        and: readonly (readonly (rdfjs.BlankNode | rdfjs.NamedNode)[])[];
+        classes: readonly rdfjs.NamedNode[];
+        comments: readonly rdfjs.Literal[];
+        datatype: purify.Maybe<rdfjs.NamedNode>;
+        deactivated: purify.Maybe<boolean>;
+        flags: readonly string[];
+        hasValues: readonly (rdfjs.BlankNode | rdfjs.NamedNode | rdfjs.Literal)[];
+        identifier: rdfjs.BlankNode | rdfjs.NamedNode;
+        in_: purify.Maybe<readonly (rdfjs.BlankNode | rdfjs.NamedNode | rdfjs.Literal)[]>;
+        isDefinedBy: purify.Maybe<rdfjs.BlankNode | rdfjs.NamedNode>;
+        labels: readonly rdfjs.Literal[];
+        languageIn: purify.Maybe<readonly string[]>;
+        maxCount: purify.Maybe<number>;
+        maxExclusive: purify.Maybe<rdfjs.Literal>;
+        maxInclusive: purify.Maybe<rdfjs.Literal>;
+        maxLength: purify.Maybe<number>;
+        minCount: purify.Maybe<number>;
+        minExclusive: purify.Maybe<rdfjs.Literal>;
+        minInclusive: purify.Maybe<rdfjs.Literal>;
+        minLength: purify.Maybe<number>;
+        nodeKind: purify.Maybe<rdfjs.NamedNode<"http://www.w3.org/ns/shacl#BlankNode" | "http://www.w3.org/ns/shacl#BlankNodeOrIRI" | "http://www.w3.org/ns/shacl#BlankNodeOrLiteral" | "http://www.w3.org/ns/shacl#IRI" | "http://www.w3.org/ns/shacl#IRIOrLiteral" | "http://www.w3.org/ns/shacl#Literal">>;
+        nodes: readonly (rdfjs.BlankNode | rdfjs.NamedNode)[];
+        not: readonly (rdfjs.BlankNode | rdfjs.NamedNode)[];
+        or: readonly (readonly (rdfjs.BlankNode | rdfjs.NamedNode)[])[];
+        patterns: readonly string[];
+        xone: readonly (readonly (rdfjs.BlankNode | rdfjs.NamedNode)[])[];
+    }>;
+}
+export interface ShaclCorePropertyShape extends BaseShaclCoreShape {
+    readonly defaultValue: purify.Maybe<rdfjs.BlankNode | rdfjs.NamedNode | rdfjs.Literal>;
+    readonly descriptions: readonly rdfjs.Literal[];
+    readonly groups: readonly (rdfjs.BlankNode | rdfjs.NamedNode)[];
+    readonly identifier: rdfjs.BlankNode | rdfjs.NamedNode;
+    readonly names: readonly rdfjs.Literal[];
+    readonly order: purify.Maybe<number>;
+    readonly path: PropertyPath;
+    readonly type: "ShaclCorePropertyShape" | "ShaclmatePropertyShape";
+    readonly uniqueLang: purify.Maybe<boolean>;
+}
+export declare namespace ShaclCorePropertyShape {
+    function propertiesFromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, ..._context }: {
+        [_index: string]: any;
+        ignoreRdfType?: boolean;
+        languageIn?: readonly string[];
+        resource: rdfjsResource.Resource;
+    }): purify.Either<rdfjsResource.Resource.ValueError, {
+        defaultValue: purify.Maybe<rdfjs.BlankNode | rdfjs.NamedNode | rdfjs.Literal>;
+        descriptions: readonly rdfjs.Literal[];
+        groups: readonly (rdfjs.BlankNode | rdfjs.NamedNode)[];
+        identifier: rdfjs.BlankNode | rdfjs.NamedNode;
+        names: readonly rdfjs.Literal[];
+        order: purify.Maybe<number>;
+        path: PropertyPath;
+        type: "ShaclCorePropertyShape" | "ShaclmatePropertyShape";
+        uniqueLang: purify.Maybe<boolean>;
+    } & purifyHelpers.Eithers.UnwrapR<ReturnType<typeof BaseShaclCoreShape.propertiesFromRdf>>>;
+    function fromRdf(parameters: Parameters<typeof ShaclCorePropertyShape.propertiesFromRdf>[0]): purify.Either<rdfjsResource.Resource.ValueError, ShaclCorePropertyShape>;
+}
+export interface ShaclmatePropertyShape extends ShaclCorePropertyShape {
+    readonly extern: purify.Maybe<boolean>;
+    readonly identifier: rdfjs.BlankNode | rdfjs.NamedNode;
+    readonly mutable: purify.Maybe<boolean>;
+    readonly name: purify.Maybe<string>;
+    readonly type: "ShaclmatePropertyShape";
+    readonly visibility: purify.Maybe<rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_Visibility_Private" | "http://minorg.github.io/shaclmate/ns#_Visibility_Protected" | "http://minorg.github.io/shaclmate/ns#_Visibility_Public">>;
+}
+export declare namespace ShaclmatePropertyShape {
+    function propertiesFromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, ..._context }: {
+        [_index: string]: any;
+        ignoreRdfType?: boolean;
+        languageIn?: readonly string[];
+        resource: rdfjsResource.Resource;
+    }): purify.Either<rdfjsResource.Resource.ValueError, {
+        extern: purify.Maybe<boolean>;
+        identifier: rdfjs.BlankNode | rdfjs.NamedNode;
+        mutable: purify.Maybe<boolean>;
+        name: purify.Maybe<string>;
+        type: "ShaclmatePropertyShape";
+        visibility: purify.Maybe<rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_Visibility_Private" | "http://minorg.github.io/shaclmate/ns#_Visibility_Protected" | "http://minorg.github.io/shaclmate/ns#_Visibility_Public">>;
+    } & purifyHelpers.Eithers.UnwrapR<ReturnType<typeof ShaclCorePropertyShape.propertiesFromRdf>>>;
+    function fromRdf(parameters: Parameters<typeof ShaclmatePropertyShape.propertiesFromRdf>[0]): purify.Either<rdfjsResource.Resource.ValueError, ShaclmatePropertyShape>;
+}
+export interface OwlOntology {
+    readonly identifier: rdfjs.BlankNode | rdfjs.NamedNode;
+    readonly labels: readonly rdfjs.Literal[];
+    readonly type: "OwlOntology" | "ShaclmateOntology";
+}
+export declare namespace OwlOntology {
+    function propertiesFromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, ..._context }: {
+        [_index: string]: any;
+        ignoreRdfType?: boolean;
+        languageIn?: readonly string[];
+        resource: rdfjsResource.Resource;
+    }): purify.Either<rdfjsResource.Resource.ValueError, {
+        identifier: rdfjs.BlankNode | rdfjs.NamedNode;
+        labels: readonly rdfjs.Literal[];
+        type: "OwlOntology" | "ShaclmateOntology";
+    }>;
+    function fromRdf(parameters: Parameters<typeof OwlOntology.propertiesFromRdf>[0]): purify.Either<rdfjsResource.Resource.ValueError, OwlOntology>;
+}
+export interface ShaclmateOntology extends OwlOntology {
+    readonly identifier: rdfjs.BlankNode | rdfjs.NamedNode;
+    readonly tsDataFactoryVariable: purify.Maybe<string>;
+    readonly tsFeatureExcludes: readonly rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">[];
+    readonly tsFeatureIncludes: readonly rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">[];
+    readonly tsImports: readonly string[];
+    readonly tsObjectDeclarationType: purify.Maybe<rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsObjectDeclarationType_Class" | "http://minorg.github.io/shaclmate/ns#_TsObjectDeclarationType_Interface">>;
+    readonly tsObjectIdentifierPropertyName: purify.Maybe<string>;
+    readonly tsObjectTypeDiscriminatorPropertyName: purify.Maybe<string>;
+    readonly type: "ShaclmateOntology";
+}
+export declare namespace ShaclmateOntology {
+    function propertiesFromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, ..._context }: {
+        [_index: string]: any;
+        ignoreRdfType?: boolean;
+        languageIn?: readonly string[];
+        resource: rdfjsResource.Resource;
+    }): purify.Either<rdfjsResource.Resource.ValueError, {
+        identifier: rdfjs.BlankNode | rdfjs.NamedNode;
+        tsDataFactoryVariable: purify.Maybe<string>;
+        tsFeatureExcludes: readonly rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">[];
+        tsFeatureIncludes: readonly rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">[];
+        tsImports: readonly string[];
+        tsObjectDeclarationType: purify.Maybe<rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsObjectDeclarationType_Class" | "http://minorg.github.io/shaclmate/ns#_TsObjectDeclarationType_Interface">>;
+        tsObjectIdentifierPropertyName: purify.Maybe<string>;
+        tsObjectTypeDiscriminatorPropertyName: purify.Maybe<string>;
+        type: "ShaclmateOntology";
+    } & purifyHelpers.Eithers.UnwrapR<ReturnType<typeof OwlOntology.propertiesFromRdf>>>;
+    function fromRdf(parameters: Parameters<typeof ShaclmateOntology.propertiesFromRdf>[0]): purify.Either<rdfjsResource.Resource.ValueError, ShaclmateOntology>;
+}
+export interface ShaclCoreNodeShape extends BaseShaclCoreShape {
+    readonly closed: purify.Maybe<boolean>;
+    readonly identifier: rdfjs.BlankNode | rdfjs.NamedNode;
+    readonly ignoredProperties: purify.Maybe<readonly rdfjs.NamedNode[]>;
+    readonly properties: readonly (rdfjs.BlankNode | rdfjs.NamedNode)[];
+    readonly type: "ShaclCoreNodeShape" | "ShaclmateNodeShape";
+}
+export declare namespace ShaclCoreNodeShape {
+    function propertiesFromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, ..._context }: {
+        [_index: string]: any;
+        ignoreRdfType?: boolean;
+        languageIn?: readonly string[];
+        resource: rdfjsResource.Resource;
+    }): purify.Either<rdfjsResource.Resource.ValueError, {
+        closed: purify.Maybe<boolean>;
+        identifier: rdfjs.BlankNode | rdfjs.NamedNode;
+        ignoredProperties: purify.Maybe<readonly rdfjs.NamedNode[]>;
+        properties: readonly (rdfjs.BlankNode | rdfjs.NamedNode)[];
+        type: "ShaclCoreNodeShape" | "ShaclmateNodeShape";
+    } & purifyHelpers.Eithers.UnwrapR<ReturnType<typeof BaseShaclCoreShape.propertiesFromRdf>>>;
+    function fromRdf(parameters: Parameters<typeof ShaclCoreNodeShape.propertiesFromRdf>[0]): purify.Either<rdfjsResource.Resource.ValueError, ShaclCoreNodeShape>;
+}
+export interface ShaclmateNodeShape extends ShaclCoreNodeShape {
+    readonly abstract: purify.Maybe<boolean>;
+    readonly export_: purify.Maybe<boolean>;
+    readonly extern: purify.Maybe<boolean>;
+    readonly fromRdfType: purify.Maybe<rdfjs.NamedNode>;
+    readonly identifier: rdfjs.BlankNode | rdfjs.NamedNode;
+    readonly mintingStrategy: purify.Maybe<rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_MintingStrategy_SHA256" | "http://minorg.github.io/shaclmate/ns#_MintingStrategy_UUIDv4">>;
+    readonly mutable: purify.Maybe<boolean>;
+    readonly name: purify.Maybe<string>;
+    readonly toRdfTypes: readonly rdfjs.NamedNode[];
+    readonly tsFeatureExcludes: readonly rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">[];
+    readonly tsFeatureIncludes: readonly rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">[];
+    readonly tsImports: readonly string[];
+    readonly tsObjectDeclarationType: purify.Maybe<rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsObjectDeclarationType_Class" | "http://minorg.github.io/shaclmate/ns#_TsObjectDeclarationType_Interface">>;
+    readonly tsObjectIdentifierPropertyName: purify.Maybe<string>;
+    readonly tsObjectTypeDiscriminatorPropertyName: purify.Maybe<string>;
+    readonly type: "ShaclmateNodeShape";
+}
+export declare namespace ShaclmateNodeShape {
+    function propertiesFromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, ..._context }: {
+        [_index: string]: any;
+        ignoreRdfType?: boolean;
+        languageIn?: readonly string[];
+        resource: rdfjsResource.Resource;
+    }): purify.Either<rdfjsResource.Resource.ValueError, {
+        abstract: purify.Maybe<boolean>;
+        export_: purify.Maybe<boolean>;
+        extern: purify.Maybe<boolean>;
+        fromRdfType: purify.Maybe<rdfjs.NamedNode>;
+        identifier: rdfjs.BlankNode | rdfjs.NamedNode;
+        mintingStrategy: purify.Maybe<rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_MintingStrategy_SHA256" | "http://minorg.github.io/shaclmate/ns#_MintingStrategy_UUIDv4">>;
+        mutable: purify.Maybe<boolean>;
+        name: purify.Maybe<string>;
+        toRdfTypes: readonly rdfjs.NamedNode[];
+        tsFeatureExcludes: readonly rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">[];
+        tsFeatureIncludes: readonly rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">[];
+        tsImports: readonly string[];
+        tsObjectDeclarationType: purify.Maybe<rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsObjectDeclarationType_Class" | "http://minorg.github.io/shaclmate/ns#_TsObjectDeclarationType_Interface">>;
+        tsObjectIdentifierPropertyName: purify.Maybe<string>;
+        tsObjectTypeDiscriminatorPropertyName: purify.Maybe<string>;
+        type: "ShaclmateNodeShape";
+    } & purifyHelpers.Eithers.UnwrapR<ReturnType<typeof ShaclCoreNodeShape.propertiesFromRdf>>>;
+    function fromRdf(parameters: Parameters<typeof ShaclmateNodeShape.propertiesFromRdf>[0]): purify.Either<rdfjsResource.Resource.ValueError, ShaclmateNodeShape>;
+}
+export interface ShaclCorePropertyGroup {
+    readonly comments: readonly rdfjs.Literal[];
+    readonly identifier: rdfjs.BlankNode | rdfjs.NamedNode;
+    readonly labels: readonly rdfjs.Literal[];
+    readonly type: "ShaclCorePropertyGroup";
+}
+export declare namespace ShaclCorePropertyGroup {
+    function propertiesFromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, ..._context }: {
+        [_index: string]: any;
+        ignoreRdfType?: boolean;
+        languageIn?: readonly string[];
+        resource: rdfjsResource.Resource;
+    }): purify.Either<rdfjsResource.Resource.ValueError, {
+        comments: readonly rdfjs.Literal[];
+        identifier: rdfjs.BlankNode | rdfjs.NamedNode;
+        labels: readonly rdfjs.Literal[];
+        type: "ShaclCorePropertyGroup";
+    }>;
+    function fromRdf(parameters: Parameters<typeof ShaclCorePropertyGroup.propertiesFromRdf>[0]): purify.Either<rdfjsResource.Resource.ValueError, ShaclCorePropertyGroup>;
+}
+export type ShaclCoreShape = ShaclCoreNodeShape | ShaclCorePropertyShape;
+export declare namespace ShaclCoreShape {
+    function fromRdf(parameters: {
+        [_index: string]: any;
+        ignoreRdfType?: boolean;
+        resource: rdfjsResource.Resource;
+    }): purify.Either<rdfjsResource.Resource.ValueError, ShaclCoreShape>;
+}
+export type ShaclmateShape = ShaclmateNodeShape | ShaclCorePropertyShape;
+export declare namespace ShaclmateShape {
+    function fromRdf(parameters: {
+        [_index: string]: any;
+        ignoreRdfType?: boolean;
+        resource: rdfjsResource.Resource;
+    }): purify.Either<rdfjsResource.Resource.ValueError, ShaclmateShape>;
+}
+//# sourceMappingURL=generated.d.ts.map