@shaclmate/compiler 4.0.21 → 4.0.23

package/dist/generators/ts/_NamedObjectType/NamedObjectType_classDeclaration.js

@@ -1,11 +1,10 @@
-import { Maybe } from "purify-ts";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, def, joinCode } from "../ts-poet-wrapper.js";
 import { tsComment } from "../tsComment.js";
 import { NamedObjectType_equalsFunctionOrMethodDeclaration } from "./NamedObjectType_equalsFunctionOrMethodDeclaration.js";
 import { NamedObjectType_hashFunctionOrMethodDeclarations } from "./NamedObjectType_hashFunctionOrMethodDeclarations.js";
 import { NamedObjectType_toJsonFunctionOrMethodDeclaration } from "./NamedObjectType_toJsonFunctionOrMethodDeclaration.js";
 import { NamedObjectType_toRdfResourceFunctionOrMethodDeclaration } from "./NamedObjectType_toRdfResourceFunctionOrMethodDeclaration.js";
+import { NamedObjectType_toStringFunctionOrMethodDeclarations } from "./NamedObjectType_toStringFunctionOrMethodDeclaration.js";
 function NamedObjectType_constructorDeclaration() {
     const parametersPropertySignatures = this.properties.flatMap((property) => property.constructorParametersSignature.toList());
     const parametersType = [];
@@ -56,14 +55,8 @@ ${joinCode([
         ...NamedObjectType_hashFunctionOrMethodDeclarations.call(this),
         ...NamedObjectType_toJsonFunctionOrMethodDeclaration.call(this).toList(),
         ...NamedObjectType_toRdfResourceFunctionOrMethodDeclaration.call(this).toList(),
-        ...NamedObjectType_toStringMethodDeclaration.call(this).toList(),
+        ...NamedObjectType_toStringFunctionOrMethodDeclarations.call(this),
     ], { on: "\n\n" })}
 }`;
 }
-function NamedObjectType_toStringMethodDeclaration() {
-    if (!this.features.has("json")) {
-        return Maybe.empty();
-    }
-    return Maybe.of(code `${this.parentObjectTypes.length > 0 ? "override " : ""}toString(): string { return JSON.stringify(this.${syntheticNamePrefix}toJson()); }`);
-}
 //# sourceMappingURL=NamedObjectType_classDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_jsonSchemaFunctionDeclaration.js

@@ -12,13 +12,22 @@ export function NamedObjectType_jsonSchemaFunctionDeclaration() {
     }
     if (this.properties.length > 0) {
         properties = properties.concat(this.properties
-            .flatMap((property) => property.jsonZchema.toList())
+            .flatMap((property) => property.jsonSchema.toList())
             .map(({ key, schema }) => code `"${key}": ${schema}`));
     }
+    const meta = {
+        id: this.name,
+    };
+    this.comment.ifJust((description) => {
+        meta["description"] = description;
+    });
+    this.label.ifJust((label) => {
+        meta["title"] = label;
+    });
     // ${this.properties.every((property) => !property.mutable) ? `.readonly()` : ""}
     return Maybe.of(code `\
 export function schema() {
-  return ${imports.z}.object({${joinCode(properties, { on: "," })}}) satisfies ${imports.z}.ZodType<${syntheticNamePrefix}Json>;
+  return ${imports.z}.object({${joinCode(properties, { on: "," })}}).meta(${meta}) satisfies ${imports.z}.ZodType<${syntheticNamePrefix}Json>;
 }`);
 }
 //# sourceMappingURL=NamedObjectType_jsonSchemaFunctionDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_toRdfResourceFunctionOrMethodDeclaration.js

@@ -20,7 +20,7 @@ export function NamedObjectType_toRdfResourceFunctionOrMethodDeclaration() {
     }
     parameters.push(code `options?: Parameters<${snippets.ToRdfResourceFunction}<${this.name}>>[1]`);
     const statements = [
-        code `const ${variables.resourceSet} = options?.${variables.resourceSet} ?? new ${imports.ResourceSet}(${imports.datasetFactory}.dataset(), { dataFactory: ${imports.dataFactory} });`,
+        code `const ${variables.resourceSet} = options?.${variables.resourceSet} ?? new ${imports.ResourceSet}({ dataFactory: ${imports.dataFactory}, dataset: ${imports.datasetFactory}.dataset() });`,
     ];
     if (this.parentObjectTypes.length > 0) {
         const superToRdfOptions = code `{ ${variables.ignoreRdfType}: true, ${variables.graph}: options?.${variables.graph}, ${variables.resourceSet} }`;

package/dist/generators/ts/_NamedObjectType/NamedObjectType_toStringFunctionOrMethodDeclaration.d.ts

@@ -0,0 +1,4 @@
+import type { NamedObjectType } from "../NamedObjectType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function NamedObjectType_toStringFunctionOrMethodDeclarations(this: NamedObjectType): readonly Code[];
+//# sourceMappingURL=NamedObjectType_toStringFunctionOrMethodDeclaration.d.ts.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_toStringFunctionOrMethodDeclaration.js

@@ -0,0 +1,62 @@
+import { snippets } from "../snippets.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
+export function NamedObjectType_toStringFunctionOrMethodDeclarations() {
+    const propertiesToStringRecordProperties = [];
+    if (this.parentObjectTypes.length > 0) {
+        switch (this.declarationType) {
+            case "class": {
+                propertiesToStringRecordProperties.push(code `...super.${syntheticNamePrefix}propertiesToStrings()`);
+                break;
+            }
+            case "interface": {
+                for (const parentObjectType of this.parentObjectTypes) {
+                    propertiesToStringRecordProperties.push(code `...${parentObjectType.staticModuleName}.${syntheticNamePrefix}propertiesToStrings(${this.thisVariable})`);
+                }
+                break;
+            }
+        }
+    }
+    for (const ownProperty of this.ownProperties) {
+        ownProperty
+            .toStringExpression({
+            variables: { value: code `${this.thisVariable}.${ownProperty.name}` },
+        })
+            .ifJust((ownPropertyToStringExpression) => {
+            propertiesToStringRecordProperties.push(code `${literalOf(ownProperty.name)}: ${ownPropertyToStringExpression}`);
+        });
+    }
+    const propertiesToStringsReturnExpression = code `${snippets.compactRecord}({${joinCode(propertiesToStringRecordProperties, { on: "," })}})`;
+    const toStringReturnExpression = (propertiesToStrings) => code `\`${this.name}(\${JSON.stringify(${propertiesToStrings})})\``;
+    switch (this.declarationType) {
+        case "class": {
+            let propertiesToStringsPreamble = "";
+            let toStringPreamble = "";
+            if (this.parentObjectTypes.length > 0) {
+                propertiesToStringsPreamble = "override ";
+                toStringPreamble = "override ";
+            }
+            propertiesToStringsPreamble = `protected ${propertiesToStringsPreamble}`;
+            return [
+                code `${propertiesToStringsPreamble}${syntheticNamePrefix}propertiesToStrings(): Record<string, string> { return ${propertiesToStringsReturnExpression}; }`,
+                code `${toStringPreamble}toString(): string { return ${toStringReturnExpression(code `this.${syntheticNamePrefix}propertiesToStrings()`)}; }`,
+            ];
+        }
+        case "interface": {
+            return [
+                // Use overloads to allow the function to be attached to an instance or used freestanding
+                code `\
+export function ${syntheticNamePrefix}propertiesToStrings(${this.thisVariable}: ${this.name}): Record<string, string> {
+  return ${propertiesToStringsReturnExpression};
+}`,
+                code `\
+export function ${syntheticNamePrefix}toString(this: ${this.name}): string;
+export function ${syntheticNamePrefix}toString(${this.thisVariable}: ${this.name}): string;
+export function ${syntheticNamePrefix}toString(this: ${this.name} | undefined, ${this.thisVariable}?: ${this.name}): string {
+  return ${toStringReturnExpression(code `${syntheticNamePrefix}propertiesToStrings((${this.thisVariable} ?? this)!)`)};
+}`,
+            ];
+        }
+    }
+}
+//# sourceMappingURL=NamedObjectType_toStringFunctionOrMethodDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/ShaclProperty.d.ts

@@ -6,14 +6,16 @@ import { AbstractProperty } from "./AbstractProperty.js";
 export declare class ShaclProperty<TypeT extends Type> extends AbstractProperty<TypeT> {
     private readonly comment;
     private readonly description;
+    private readonly display;
     private readonly label;
     readonly kind = "ShaclProperty";
     readonly mutable: boolean;
     readonly path: PropertyPath;
     readonly recursive: boolean;
-    constructor({ comment, description, label, mutable, path, recursive, ...superParameters }: {
+    constructor({ comment, description, display, label, mutable, path, recursive, ...superParameters }: {
         comment: Maybe<string>;
         description: Maybe<string>;
+        display: boolean;
         label: Maybe<string>;
         mutable: boolean;
         path: PropertyPath;
@@ -28,8 +30,8 @@ export declare class ShaclProperty<TypeT extends Type> extends AbstractProperty<
     }>;
     get getAccessorDeclaration(): Maybe<Code>;
     get graphqlField(): AbstractProperty<TypeT>["graphqlField"];
+    get jsonSchema(): AbstractProperty<TypeT>["jsonSchema"];
     get jsonSignature(): Maybe<Code>;
-    get jsonZchema(): AbstractProperty<TypeT>["jsonZchema"];
     protected get schemaObject(): {
         path: Code | undefined;
         kind: Code;
@@ -44,6 +46,7 @@ export declare class ShaclProperty<TypeT extends Type> extends AbstractProperty<
     sparqlWherePatternsExpression({ variables, }: Parameters<AbstractProperty<TypeT>["sparqlWherePatternsExpression"]>[0]): ReturnType<AbstractProperty<TypeT>["sparqlWherePatternsExpression"]>;
     toJsonObjectMemberExpression(parameters: Parameters<AbstractProperty<TypeT>["toJsonObjectMemberExpression"]>[0]): Maybe<Code>;
     toRdfRdfResourceValuesStatements({ variables, }: Parameters<AbstractProperty<TypeT>["toRdfRdfResourceValuesStatements"]>[0]): readonly Code[];
+    toStringExpression(parameters: Parameters<AbstractProperty<TypeT>["toStringExpression"]>[0]): Maybe<Code>;
     private propertyPathToCode;
 }
 //# sourceMappingURL=ShaclProperty.d.ts.map

package/dist/generators/ts/_NamedObjectType/ShaclProperty.js

@@ -16,15 +16,17 @@ import { AbstractProperty } from "./AbstractProperty.js";
 export class ShaclProperty extends AbstractProperty {
     comment;
     description;
+    display;
     label;
     kind = "ShaclProperty";
     mutable;
     path;
     recursive;
-    constructor({ comment, description, label, mutable, path, recursive, ...superParameters }) {
+    constructor({ comment, description, display, label, mutable, path, recursive, ...superParameters }) {
         super(superParameters);
         this.comment = comment;
         this.description = description;
+        this.display = display;
         this.label = label;
         this.mutable = mutable;
         this.path = path;
@@ -85,22 +87,29 @@ export class ShaclProperty extends AbstractProperty {
             type: this.type.graphqlType.name,
         });
     }
-    get jsonSignature() {
-        const typeJsonType = this.type.jsonType();
-        return Maybe.of(code `${!this.mutable ? "readonly " : ""}${this.name}${typeJsonType.optional ? "?" : ""}: ${typeJsonType.requiredName}`);
-    }
-    get jsonZchema() {
+    get jsonSchema() {
         let schema = this.type.jsonSchema({
             context: "property",
         });
+        const meta = {
+            id: this.name,
+        };
         this.comment.alt(this.description).ifJust((description) => {
-            schema = code `${schema}.describe(${literalOf(description)})`;
+            meta["description"] = description;
+        });
+        this.label.ifJust((label) => {
+            meta["title"] = label;
         });
+        schema = code `${schema}.meta(${meta})`;
         return Maybe.of({
             key: this.name,
             schema,
         });
     }
+    get jsonSignature() {
+        const typeJsonType = this.type.jsonType();
+        return Maybe.of(code `${!this.mutable ? "readonly " : ""}${this.name}${typeJsonType.optional ? "?" : ""}: ${typeJsonType.requiredName}`);
+    }
     get schemaObject() {
         return {
             ...super.schemaObject,
@@ -228,6 +237,12 @@ export class ShaclProperty extends AbstractProperty {
             })}, ${variables.graph});`,
         ];
     }
+    toStringExpression(parameters) {
+        if (!this.display) {
+            return Maybe.empty();
+        }
+        return Maybe.of(this.type.toStringExpression(parameters));
+    }
     propertyPathToCode(propertyPath) {
         switch (propertyPath.termType) {
             case "AlternativePath":
@@ -260,8 +275,8 @@ __decorate([
 ], ShaclProperty.prototype, "graphqlField", null);
 __decorate([
     Memoize()
-], ShaclProperty.prototype, "jsonSignature", null);
+], ShaclProperty.prototype, "jsonSchema", null);
 __decorate([
     Memoize()
-], ShaclProperty.prototype, "jsonZchema", null);
+], ShaclProperty.prototype, "jsonSignature", null);
 //# sourceMappingURL=ShaclProperty.js.map

package/dist/generators/ts/_snippets/snippets_PropertyPath.js

@@ -8,7 +8,7 @@ import { snippets_ToRdfResourceFunction } from "./snippets_ToRdfResourceFunction
  * Adapter between generated code and the rdfjs-resource PropertyPath.
  */
 export const snippets_PropertyPath = conditionalOutput(`${syntheticNamePrefix}PropertyPath`, code `\
-export type ${syntheticNamePrefix}PropertyPath = ${imports.RdfjsResourcePropertyPath};
+export type ${syntheticNamePrefix}PropertyPath = ${imports.RdfxResourcePropertyPath};
 
 export namespace ${syntheticNamePrefix}PropertyPath {
   export type $Filter = object;
@@ -17,7 +17,7 @@ export namespace ${syntheticNamePrefix}PropertyPath {
     return true;
   }
 
-  export const ${syntheticNamePrefix}fromRdfResource: ${snippets_FromRdfResourceFunction}<${syntheticNamePrefix}PropertyPath> = ${imports.RdfjsResourcePropertyPath}.fromResource;
+  export const ${syntheticNamePrefix}fromRdfResource: ${snippets_FromRdfResourceFunction}<${syntheticNamePrefix}PropertyPath> = ${imports.RdfxResourcePropertyPath}.fromResource;
 
   export const $fromRdfResourceValues: ${snippets_FromRdfResourceValuesFunction}<${syntheticNamePrefix}PropertyPath> = (values, options) =>
     values.chain((values) =>
@@ -30,6 +30,8 @@ export namespace ${syntheticNamePrefix}PropertyPath {
 
   export const $schema: Readonly<object> = {};
 
-  export const ${syntheticNamePrefix}toRdfResource: ${snippets_ToRdfResourceFunction}<${syntheticNamePrefix}PropertyPath> = ${imports.RdfjsResourcePropertyPath}.toResource;
+  export const ${syntheticNamePrefix}toRdfResource: ${snippets_ToRdfResourceFunction}<${syntheticNamePrefix}PropertyPath> = ${imports.RdfxResourcePropertyPath}.toResource;
+
+  export const ${syntheticNamePrefix}toString = ${imports.RdfxResourcePropertyPath}.toString;
 }`);
 //# sourceMappingURL=snippets_PropertyPath.js.map

package/dist/generators/ts/_snippets/snippets_compactRecord.d.ts

@@ -0,0 +1,2 @@
+export declare const snippets_compactRecord: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+//# sourceMappingURL=snippets_compactRecord.d.ts.map

package/dist/generators/ts/_snippets/snippets_compactRecord.js

@@ -0,0 +1,16 @@
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_compactRecord = conditionalOutput(`${syntheticNamePrefix}compactRecord`, code `\
+/**
+ * Remove undefined values from a record.
+ */  
+function ${syntheticNamePrefix}compactRecord<KeyT extends string, ValueT extends {}>(record: Record<KeyT, ValueT | undefined>): Record<KeyT, ValueT> {
+  return \
+    Object.entries(record).reduce((definedProperties, [propertyName, propertyValue]) => {
+      if (propertyValue !== undefined) {
+        definedProperties[propertyName as KeyT] = propertyValue as ValueT;
+      }
+      return definedProperties;
+    }, {} as Record<KeyT, ValueT>);
+}`);
+//# sourceMappingURL=snippets_compactRecord.js.map

package/dist/generators/ts/_snippets/{parseIri.d.ts → snippets_parseIri.d.ts}

@@ -1,2 +1,2 @@
 export declare const snippets_parseIri: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
-//# sourceMappingURL=parseIri.d.ts.map
+//# sourceMappingURL=snippets_parseIri.d.ts.map

package/dist/generators/ts/_snippets/{parseIri.js → snippets_parseIri.js}

@@ -9,4 +9,4 @@ export function ${syntheticNamePrefix}parseIri(identifier: string): ${imports.Ei
       .chain((identifier) => (identifier.termType === "NamedNode") ? ${imports.Right}(identifier) : ${imports.Left}(new Error("expected identifier to be NamedNode"))) \
     as ${imports.Either}<Error, ${imports.NamedNode}>;
 }`);
-//# sourceMappingURL=parseIri.js.map
+//# sourceMappingURL=snippets_parseIri.js.map

package/dist/generators/ts/imports.d.ts

@@ -29,7 +29,7 @@ export declare const imports: {
     readonly NTriplesTerm: import("ts-poet/build/Import.js").Import;
     readonly Quad: import("ts-poet/build/Import.js").Import;
     readonly Quad_Graph: import("ts-poet/build/Import.js").Import;
-    readonly RdfjsResourcePropertyPath: import("ts-poet/build/Import.js").Import;
+    readonly RdfxResourcePropertyPath: import("ts-poet/build/Import.js").Import;
     readonly Resource: import("ts-poet/build/Import.js").Import;
     readonly ResourceSet: import("ts-poet/build/Import.js").Import;
     readonly Right: import("ts-poet/build/Import.js").Import;

package/dist/generators/ts/imports.js

@@ -30,7 +30,7 @@ export const imports = {
     NTriplesTerm: imp("NTriplesTerm@@rdfx/string"),
     Quad: imp("Quad@@rdfjs/types"),
     Quad_Graph: imp("Quad_Graph@@rdfjs/types"),
-    RdfjsResourcePropertyPath: imp("PropertyPath:RdfjsResourcePropertyPath@@rdfx/resource"),
+    RdfxResourcePropertyPath: imp("PropertyPath:RdfxResourcePropertyPath@@rdfx/resource"),
     Resource: imp("Resource@@rdfx/resource"),
     ResourceSet: imp("ResourceSet@@rdfx/resource"),
     Right: imp("Right@purify-ts"),

package/dist/generators/ts/rdfjsDatasetObjectSetClassDeclaration.js

@@ -37,7 +37,7 @@ export class ${syntheticNamePrefix}RdfjsDatasetObjectSet implements ${syntheticN
   }
 
   protected ${syntheticNamePrefix}resourceSet(): ${imports.ResourceSet} {
-    return new ${imports.ResourceSet}(this.${syntheticNamePrefix}dataset(), { dataFactory: ${imports.dataFactory} });
+    return new ${imports.ResourceSet}({ dataFactory: ${imports.dataFactory}, dataset: this.${syntheticNamePrefix}dataset() });
   }
 
   ${joinCode([

package/dist/generators/ts/snippets.d.ts

@@ -12,6 +12,7 @@ export declare const snippets: {
     booleanSparqlWherePatterns: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
     CollectionFilter: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
     CollectionSchema: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+    compactRecord: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
     dateEquals: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
     DateFilter: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
     DateSchema: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;

package/dist/generators/ts/snippets.js

@@ -1,4 +1,3 @@
-import { snippets_parseIri } from "./_snippets/parseIri.js";
 import { snippets_arrayEquals } from "./_snippets/snippets_arrayEquals.js";
 import { snippets_arrayIntersection } from "./_snippets/snippets_arrayIntersection.js";
 import { snippets_BlankNodeFilter } from "./_snippets/snippets_BlankNodeFilter.js";
@@ -12,6 +11,7 @@ import { snippets_booleanEquals } from "./_snippets/snippets_booleanEquals.js";
 import { snippets_booleanSparqlWherePatterns } from "./_snippets/snippets_booleanSparqlWherePatterns.js";
 import { snippets_CollectionFilter } from "./_snippets/snippets_CollectionFilter.js";
 import { snippets_CollectionSchema } from "./_snippets/snippets_CollectionSchema.js";
+import { snippets_compactRecord } from "./_snippets/snippets_compactRecord.js";
 import { snippets_DateFilter } from "./_snippets/snippets_DateFilter.js";
 import { snippets_DateSchema } from "./_snippets/snippets_DateSchema.js";
 import { snippets_DefaultValueSchema } from "./_snippets/snippets_DefaultValueSchema.js";
@@ -76,6 +76,7 @@ import { snippets_PropertiesFromRdfResourceFunction } from "./_snippets/snippets
 import { snippets_PropertyPath } from "./_snippets/snippets_PropertyPath.js";
 import { snippets_parseBlankNode } from "./_snippets/snippets_parseBlankNode.js";
 import { snippets_parseIdentifier } from "./_snippets/snippets_parseIdentifier.js";
+import { snippets_parseIri } from "./_snippets/snippets_parseIri.js";
 import { snippets_RdfVocabularies } from "./_snippets/snippets_RdfVocabularies.js";
 import { snippets_ShaclPropertySchema } from "./_snippets/snippets_ShaclPropertySchema.js";
 import { snippets_SparqlFilterPattern } from "./_snippets/snippets_SparqlFilterPattern.js";
@@ -118,6 +119,7 @@ export const snippets = {
     booleanSparqlWherePatterns: snippets_booleanSparqlWherePatterns,
     CollectionFilter: snippets_CollectionFilter,
     CollectionSchema: snippets_CollectionSchema,
+    compactRecord: snippets_compactRecord,
     dateEquals: snippets_dateEquals,
     DateFilter: snippets_DateFilter,
     DateSchema: snippets_DateSchema,

package/dist/generators/ts/sparqlObjectSetClassDeclaration.js

@@ -161,7 +161,7 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
       const dataset = ${imports.datasetFactory}.dataset(quads.concat());
       const objects: ObjectT[] = [];
       for (const identifier of identifiers) {
-        objects.push(await liftEither(namedObjectType.${syntheticNamePrefix}fromRdfResource(new ${imports.Resource}(dataset, identifier as ${imports.NamedNode}), { objectSet: this, preferredLanguages: query?.preferredLanguages })));
+        objects.push(await liftEither(namedObjectType.${syntheticNamePrefix}fromRdfResource(new ${imports.Resource}({ dataFactory: ${imports.dataFactory}, dataset: dataset, identifier: identifier as ${imports.NamedNode} }), { objectSet: this, preferredLanguages: query?.preferredLanguages })));
       }
       return objects;
     });

package/dist/input/generated.d.ts

@@ -1,5 +1,5 @@
 import type { BlankNode, DatasetCore, Literal, NamedNode, Quad_Graph, Variable } from "@rdfjs/types";
-import { PropertyPath as RdfjsResourcePropertyPath, Resource, ResourceSet } from "@rdfx/resource";
+import { PropertyPath as RdfxResourcePropertyPath, Resource, ResourceSet } from "@rdfx/resource";
 import { NTriplesTerm } from "@rdfx/string";
 import { Either, Maybe } from "purify-ts";
 interface $BooleanFilter {
@@ -9,6 +9,43 @@ type $CollectionFilter<ItemFilterT> = ItemFilterT & {
     readonly $maxCount?: number;
     readonly $minCount?: number;
 };
+export type $EqualsResult = Either<$EqualsResult.Unequal, true>;
+export declare namespace $EqualsResult {
+    const Equal: $EqualsResult;
+    function fromBooleanEqualsResult(left: any, right: any, equalsResult: boolean | $EqualsResult): $EqualsResult;
+    type Unequal = {
+        readonly left: {
+            readonly array: readonly any[];
+            readonly element: any;
+            readonly elementIndex: number;
+        };
+        readonly right: {
+            readonly array: readonly any[];
+            readonly unequals: readonly Unequal[];
+        };
+        readonly type: "array-element";
+    } | {
+        readonly left: readonly any[];
+        readonly right: readonly any[];
+        readonly type: "array-length";
+    } | {
+        readonly left: any;
+        readonly right: any;
+        readonly type: "boolean";
+    } | {
+        readonly right: any;
+        readonly type: "left-null";
+    } | {
+        readonly left: any;
+        readonly right: any;
+        readonly propertyName: string;
+        readonly propertyValuesUnequal: Unequal;
+        readonly type: "property";
+    } | {
+        readonly left: any;
+        readonly type: "right-null";
+    };
+}
 export type $FromRdfResourceFunction<T> = (resource: Resource, options?: {
     context?: unknown;
     graph?: Exclude<Quad_Graph, Variable>;
@@ -50,7 +87,7 @@ type $PropertiesFromRdfResourceFunction<T> = (resource: Resource, options: {
     objectSet: $ObjectSet;
     preferredLanguages?: readonly string[];
 }) => Either<Error, T>;
-export type $PropertyPath = RdfjsResourcePropertyPath;
+export type $PropertyPath = RdfxResourcePropertyPath;
 export declare namespace $PropertyPath {
     type $Filter = object;
     function $filter(_filter: $Filter, _value: $PropertyPath): boolean;
@@ -58,6 +95,7 @@ export declare namespace $PropertyPath {
     const $fromRdfResourceValues: $FromRdfResourceValuesFunction<$PropertyPath>;
     const $schema: Readonly<object>;
     const $toRdfResource: $ToRdfResourceFunction<$PropertyPath>;
+    const $toString: typeof RdfxResourcePropertyPath.toString;
 }
 export interface $ShaclPropertySchema<TypeSchemaT = object> {
     readonly kind: "Shacl";
@@ -80,13 +118,13 @@ export type $ToRdfResourceFunction<T> = (value: T, options?: {
     ignoreRdfType?: boolean;
     resourceSet?: ResourceSet;
 }) => Resource;
-export type $ToRdfResourceValuesFunction<T> = (value: T, options: {
+export type $ToRdfResourceValuesFunction<ValueT, ReturnT extends BlankNode | Literal | NamedNode = BlankNode | Literal | NamedNode> = (value: ValueT, options: {
     graph?: Exclude<Quad_Graph, Variable>;
     ignoreRdfType?: boolean;
     propertyPath: $PropertyPath;
     resource: Resource;
     resourceSet: ResourceSet;
-}) => (bigint | boolean | number | string | BlankNode | Literal | NamedNode)[];
+}) => ReturnT[];
 export interface PropertyShape {
     readonly $identifier: PropertyShape.$Identifier;
     readonly $type: "PropertyShape";
@@ -96,7 +134,10 @@ export interface PropertyShape {
     readonly datatype: Maybe<NamedNode>;
     readonly deactivated: Maybe<boolean>;
     readonly defaultValue: Maybe<NamedNode | Literal>;
-    readonly description: Maybe<string>;
+    readonly description: Maybe<string> /**
+     * Whether to include this property in a toString()-type display, defaults to false
+     */;
+    readonly display: boolean;
     readonly flags: readonly string[];
     readonly groups: readonly (BlankNode | NamedNode)[];
     readonly hasValues: readonly (NamedNode | Literal)[];
@@ -137,6 +178,7 @@ export declare namespace PropertyShape {
         readonly deactivated?: Maybe<boolean> | boolean;
         readonly defaultValue?: Maybe<NamedNode | Literal> | bigint | boolean | Date | number | string | (NamedNode | Literal);
         readonly description?: Maybe<string> | string;
+        readonly display?: boolean;
         readonly flags?: readonly string[];
         readonly groups?: readonly (BlankNode | NamedNode)[] | readonly string[];
         readonly hasValues?: readonly (NamedNode | Literal)[] | readonly bigint[] | readonly boolean[] | readonly number[] | readonly string[];
@@ -182,6 +224,7 @@ export declare namespace PropertyShape {
         readonly deactivated?: $MaybeFilter<$BooleanFilter>;
         readonly defaultValue?: $MaybeFilter<$TermFilter>;
         readonly description?: $MaybeFilter<$StringFilter>;
+        readonly display?: $BooleanFilter;
         readonly flags?: $CollectionFilter<$StringFilter>;
         readonly groups?: $CollectionFilter<$IdentifierFilter>;
         readonly hasValues?: $CollectionFilter<$TermFilter>;
@@ -226,6 +269,7 @@ export declare namespace PropertyShape {
         deactivated: Maybe<boolean>;
         defaultValue: Maybe<NamedNode | Literal>;
         description: Maybe<string>;
+        display: boolean;
         flags: readonly string[];
         groups: readonly (BlankNode | NamedNode)[];
         hasValues: readonly (NamedNode | Literal)[];
@@ -344,6 +388,17 @@ export declare namespace PropertyShape {
                 };
                 readonly path: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#description">;
             };
+            readonly display: {
+                readonly kind: "Shacl";
+                readonly type: () => {
+                    kind: "DefaultValue";
+                    item: () => {
+                        kind: "Boolean";
+                    };
+                    defaultValue: import("@rdfx/data-factory/dist/Literal.js").Literal;
+                };
+                readonly path: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://purl.org/shaclmate/ontology#display">;
+            };
             readonly flags: {
                 readonly kind: "Shacl";
                 readonly type: () => {
@@ -646,6 +701,9 @@ export declare namespace PropertyShape {
         };
     };
     function $toRdfResource(_propertyShape: PropertyShape, options?: Parameters<$ToRdfResourceFunction<PropertyShape>>[1]): Resource;
+    function $propertiesToStrings(_propertyShape: PropertyShape): Record<string, string>;
+    function $toString(this: PropertyShape): string;
+    function $toString(_propertyShape: PropertyShape): string;
 }
 export interface PropertyGroup {
     readonly $identifier: PropertyGroup.$Identifier;
@@ -718,6 +776,9 @@ export declare namespace PropertyGroup {
         };
     };
     function $toRdfResource(_propertyGroup: PropertyGroup, options?: Parameters<$ToRdfResourceFunction<PropertyGroup>>[1]): Resource;
+    function $propertiesToStrings(_propertyGroup: PropertyGroup): Record<string, string>;
+    function $toString(this: PropertyGroup): string;
+    function $toString(_propertyGroup: PropertyGroup): string;
 }
 export interface Ontology {
     readonly $identifier: Ontology.$Identifier;
@@ -849,6 +910,9 @@ export declare namespace Ontology {
         };
     };
     function $toRdfResource(_ontology: Ontology, options?: Parameters<$ToRdfResourceFunction<Ontology>>[1]): Resource;
+    function $propertiesToStrings(_ontology: Ontology): Record<string, string>;
+    function $toString(this: Ontology): string;
+    function $toString(_ontology: Ontology): string;
 }
 export interface NodeShape {
     readonly $identifier: NodeShape.$Identifier;
@@ -1518,6 +1582,9 @@ export declare namespace NodeShape {
         };
     };
     function $toRdfResource(_nodeShape: NodeShape, options?: Parameters<$ToRdfResourceFunction<NodeShape>>[1]): Resource;
+    function $propertiesToStrings(_nodeShape: NodeShape): Record<string, string>;
+    function $toString(this: NodeShape): string;
+    function $toString(_nodeShape: NodeShape): string;
 }
 export type Shape = NodeShape | PropertyShape;
 export declare namespace Shape {
@@ -2102,6 +2169,17 @@ export declare namespace Shape {
                             };
                             readonly path: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#description">;
                         };
+                        readonly display: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "DefaultValue";
+                                item: () => {
+                                    kind: "Boolean";
+                                };
+                                defaultValue: import("@rdfx/data-factory/dist/Literal.js").Literal;
+                            };
+                            readonly path: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://purl.org/shaclmate/ontology#display">;
+                        };
                         readonly flags: {
                             readonly kind: "Shacl";
                             readonly type: () => {
@@ -2695,7 +2773,14 @@ export declare namespace Shape {
         };
     };
     const $toRdfResource: $ToRdfResourceFunction<Shape>;
-    const $toRdfResourceValues: $ToRdfResourceValuesFunction<Shape>;
+    const $toRdfResourceValues: (value: Shape, _options: {
+        graph?: Exclude<Quad_Graph, Variable>;
+        ignoreRdfType?: boolean;
+        propertyPath: $PropertyPath;
+        resource: Resource;
+        resourceSet: ResourceSet;
+    }) => (BlankNode | NamedNode)[];
+    const $toString: (value: Shape) => string;
     function isShape(object: $Object): object is Shape;
 }
 export type $Object = NodeShape | Ontology | PropertyGroup | PropertyShape;
@@ -3406,6 +3491,17 @@ export declare namespace $Object {
                             };
                             readonly path: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://www.w3.org/ns/shacl#description">;
                         };
+                        readonly display: {
+                            readonly kind: "Shacl";
+                            readonly type: () => {
+                                kind: "DefaultValue";
+                                item: () => {
+                                    kind: "Boolean";
+                                };
+                                defaultValue: import("@rdfx/data-factory/dist/Literal.js").Literal;
+                            };
+                            readonly path: import("@rdfx/data-factory/dist/NamedNode.js").NamedNode<"http://purl.org/shaclmate/ontology#display">;
+                        };
                         readonly flags: {
                             readonly kind: "Shacl";
                             readonly type: () => {
@@ -3733,7 +3829,14 @@ export declare namespace $Object {
         };
     };
     const $toRdfResource: $ToRdfResourceFunction<$Object>;
-    const $toRdfResourceValues: $ToRdfResourceValuesFunction<$Object>;
+    const $toRdfResourceValues: (value: $Object, _options: {
+        graph?: Exclude<Quad_Graph, Variable>;
+        ignoreRdfType?: boolean;
+        propertyPath: $PropertyPath;
+        resource: Resource;
+        resourceSet: ResourceSet;
+    }) => (BlankNode | NamedNode)[];
+    const $toString: (value: $Object) => string;
 }
 export interface $ObjectSet {
     nodeShape(identifier: NodeShape.$Identifier, options?: {