@shaclmate/compiler 4.0.30 → 4.0.32

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

@@ -1,45 +1,39 @@
 import { rdf } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
 export function NamedObjectType_toRdfResourceFunctionDeclaration() {
     if (!this.features.has("rdf")) {
         return Maybe.empty();
     }
-    const statements = [
-        code `const ${variables.resourceSet} = options?.${variables.resourceSet} ?? new ${this.reusables.imports.ResourceSet}({ dataFactory: ${this.reusables.imports.dataFactory}, dataset: ${this.reusables.imports.datasetFactory}.dataset() });`,
-    ];
-    if (this.parentObjectTypes.length > 0) {
-        statements.push(code `const ${variables.resource} = ${this.parentObjectTypes[0].name}.toRdfResource(${this.thisVariable}, { ${variables.ignoreRdfType}: true, ${variables.graph}: options?.${variables.graph}, ${variables.resourceSet} });`);
-    }
-    else {
-        statements.push(code `const ${variables.resource} = ${variables.resourceSet}.resource(${this.thisVariable}.${syntheticNamePrefix}identifier());`);
-    }
+    const statements = this.parentObjectTypes.map((parentObjectType) => code `${parentObjectType.name}._toRdfResource({ ...parameters, ignoreRdfType: true });`);
     if (this.toRdfTypes.length > 0) {
-        statements.push(code `if (!options?.${variables.ignoreRdfType}) { ${joinCode(this.toRdfTypes.map((toRdfType) => code `${variables.resource}.add(${this.rdfjsTermExpression(rdf.type)}, ${this.reusables.imports.dataFactory}.namedNode("${toRdfType.value}"), options?.${variables.graph});`), { on: " " })} }`);
+        statements.push(code `if (!${variables.ignoreRdfType}) { ${joinCode(this.toRdfTypes.map((toRdfType) => code `${variables.resource}.add(${this.rdfjsTermExpression(rdf.type)}, ${this.reusables.imports.dataFactory}.namedNode("${toRdfType.value}"), ${variables.graph});`), { on: " " })} }`);
     }
     for (const property of this.properties) {
         statements.push(...property.toRdfRdfResourceValuesStatements({
             variables: {
-                graph: code `options?.${variables.graph}`,
+                graph: variables.graph,
                 resource: variables.resource,
                 resourceSet: variables.resourceSet,
                 value: property.accessExpression({
-                    variables: { object: this.thisVariable },
+                    variables: { object: variables.object },
                 }),
             },
         }));
     }
     statements.push(code `return ${variables.resource};`);
     return Maybe.of(code `\
-export function toRdfResource(${this.thisVariable}: ${this.name}, options?: Parameters<${this.reusables.snippets.ToRdfResourceFunction}<${this.name}>>[1]): ${this.toRdfjsResourceType} {
-  ${joinCode(statements)}
-}`);
+export const _toRdfResource: ${this.reusables.snippets._ToRdfResourceFunction}<${this.identifierTypeAlias}, ${this.name}> = (parameters) => {
+${joinCode(statements)}
+}
+
+export const toRdfResource = ${this.reusables.snippets.wrap_ToRdfResourceFunction}(_toRdfResource);`);
 }
 const variables = {
-    ignoreRdfType: code `ignoreRdfType`,
-    graph: code `graph`,
-    resource: code `resource`,
-    resourceSet: code `resourceSet`,
+    ignoreRdfType: code `parameters.ignoreRdfType`,
+    graph: code `parameters.graph`,
+    object: code `parameters.object`,
+    resource: code `parameters.resource`,
+    resourceSet: code `parameters.resourceSet`,
 };
 //# sourceMappingURL=NamedObjectType_toRdfResourceFunctionDeclaration.js.map

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

@@ -4,7 +4,7 @@ export function NamedObjectType_toStringFunctionDeclarations() {
     const propertiesToStringRecordProperties = [];
     if (this.parentObjectTypes.length > 0) {
         for (const parentObjectType of this.parentObjectTypes) {
-            propertiesToStringRecordProperties.push(code `...${parentObjectType.name}.propertiesToStrings(${this.thisVariable})`);
+            propertiesToStringRecordProperties.push(code `...${parentObjectType.name}._propertiesToStrings(${this.thisVariable})`);
         }
     }
     for (const property of this.properties) {
@@ -25,14 +25,14 @@ export function NamedObjectType_toStringFunctionDeclarations() {
     return [
         // Use overloads to allow the function to be attached to an instance or used freestanding
         code `\
-export function propertiesToStrings(${this.thisVariable}: ${this.name}): Record<string, string> {
+export function _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 `propertiesToStrings((${this.thisVariable} ?? this)!)`)};
+  return ${toStringReturnExpression(code `_propertiesToStrings((${this.thisVariable} ?? this)!)`)};
 }`,
     ];
 }

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

@@ -36,7 +36,7 @@ export declare class ShaclProperty<TypeT extends Type> extends AbstractProperty<
         type: Code;
     };
     constructorStatements({ variables, }: Parameters<AbstractProperty<TypeT>["constructorStatements"]>[0]): readonly Code[];
-    fromJsonStatements({ variables, }: Parameters<AbstractProperty<TypeT>["fromJsonStatements"]>[0]): readonly Code[];
+    fromJsonExpression({ variables, }: Parameters<AbstractProperty<TypeT>["fromJsonExpression"]>[0]): Maybe<Code>;
     fromRdfResourceValuesExpression({ variables, }: Parameters<AbstractProperty<TypeT>["fromRdfResourceValuesExpression"]>[0]): Maybe<Code>;
     hashStatements(parameters: Parameters<AbstractProperty<TypeT>["hashStatements"]>[0]): readonly Code[];
     jsonUiSchemaElement({ variables, }: Parameters<AbstractProperty<TypeT>["jsonUiSchemaElement"]>[0]): Maybe<Code>;

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

@@ -123,10 +123,10 @@ export class ShaclProperty extends AbstractProperty {
             .concat(code `{ ${this.name} = (${variables.parameter}) satisfies never; }`), { on: " else " }));
         return statements;
     }
-    fromJsonStatements({ variables, }) {
-        return [
-            code `const ${this.name} = ${this.type.fromJsonExpression({ variables: { value: code `${variables.jsonObject}["${this.name}"]` } })};`,
-        ];
+    fromJsonExpression({ variables, }) {
+        return Maybe.of(this.type.fromJsonExpression({
+            variables: { value: code `${variables.jsonObject}["${this.name}"]` },
+        }));
     }
     fromRdfResourceValuesExpression({ variables, }) {
         // Assume the property has the correct range and ignore the object's RDF type.

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

@@ -1,5 +1,11 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_ToRdfResourceFunction = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}ToRdfResourceFunction`, code `\
-export type ${syntheticNamePrefix}ToRdfResourceFunction<T> =
-    (value: T, options?: { graph?: Exclude<${imports.Quad_Graph}, ${imports.Variable}>; ignoreRdfType?: boolean; resourceSet?: ${imports.ResourceSet}; }) => ${imports.Resource};`);
+export type ${syntheticNamePrefix}ToRdfResourceFunction<ObjectT, IdentifierT extends ${imports.Resource}.Identifier = ${imports.Resource}.Identifier> = (
+  object: ObjectT,
+  options?: {
+    graph?: Exclude<${imports.Quad_Graph}, ${imports.Variable}>;
+    ignoreRdfType?: boolean;
+    resourceSet?: ${imports.ResourceSet};
+  }
+) => ${imports.Resource}<IdentifierT>;`);
 //# sourceMappingURL=snippets_ToRdfResourceFunction.js.map

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

@@ -0,0 +1,3 @@
+import type { SnippetFactory } from "../SnippetFactory.js";
+export declare const snippets__FromRdfResourceFunction: SnippetFactory;
+//# sourceMappingURL=snippets__FromRdfResourceFunction.d.ts.map

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

@@ -0,0 +1,13 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets__FromRdfResourceFunction = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}_FromRdfResourceFunction`, code `\
+type ${syntheticNamePrefix}_FromRdfResourceFunction<T> = (
+  resource: ${imports.Resource},
+  options: {
+    context: undefined | unknown;
+    graph: Exclude<${imports.Quad_Graph}, ${imports.Variable}> | undefined;
+    ignoreRdfType: boolean;
+    objectSet: ${syntheticNamePrefix}ObjectSet;
+    preferredLanguages: readonly string[] | undefined;
+  }
+) => ${imports.Either}<Error, T>;`);
+//# sourceMappingURL=snippets__FromRdfResourceFunction.js.map

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

@@ -0,0 +1,3 @@
+import type { SnippetFactory } from "../SnippetFactory.js";
+export declare const snippets__ToRdfResourceFunction: SnippetFactory;
+//# sourceMappingURL=snippets__ToRdfResourceFunction.d.ts.map

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

@@ -0,0 +1,12 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets__ToRdfResourceFunction = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}_ToRdfResourceFunction`, code `\
+export type ${syntheticNamePrefix}_ToRdfResourceFunction<IdentifierT extends ${imports.Resource}.Identifier, ObjectT extends { ${syntheticNamePrefix}identifier: () => IdentifierT }> = (
+  parameters: {
+    graph: Exclude<${imports.Quad_Graph}, ${imports.Variable}> | undefined;
+    ignoreRdfType: boolean;
+    object: ObjectT
+    resource: ${imports.Resource}<IdentifierT>;
+    resourceSet: ${imports.ResourceSet};
+  }
+) => void;`);
+//# sourceMappingURL=snippets__ToRdfResourceFunction.js.map

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

@@ -0,0 +1,3 @@
+import type { SnippetFactory } from "../SnippetFactory.js";
+export declare const snippets_sequenceRecord: SnippetFactory;
+//# sourceMappingURL=snippets_sequenceRecord.d.ts.map

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

@@ -0,0 +1,18 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_sequenceRecord = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}sequenceRecord`, code `\
+function ${syntheticNamePrefix}sequenceRecord<T extends Record<string, unknown>>(
+  record: { [K in keyof T]: ${imports.Either}<Error, T[K]> }
+): ${imports.Either}<Error, T> {
+  const result: { [K in keyof T]?: T[K] } = {};
+
+  for (const key of globalThis.Object.keys(record) as Array<keyof T>) {
+    const either = record[key];
+    if (either.isLeft()) {
+      return either as unknown as ${imports.Either}<Error, T>;
+    }
+    result[key] = either.extract() as T[typeof key];
+  }
+
+  return ${imports.Right}(result as T);
+}`);
+//# sourceMappingURL=snippets_sequenceRecord.js.map

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

@@ -0,0 +1,3 @@
+import type { SnippetFactory } from "../SnippetFactory.js";
+export declare const snippets_wrap_FromRdfResourceFunction: SnippetFactory;
+//# sourceMappingURL=snippets_wrap_FromRdfResourceFunction.d.ts.map

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

@@ -0,0 +1,10 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_wrap_FromRdfResourceFunction = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}wrap_FromRdfResourceFunction`, code `\
+function ${syntheticNamePrefix}wrap_FromRdfResourceFunction<T>(_fromRdfResourceFunction: ${snippets._FromRdfResourceFunction}<T>): ${snippets.FromRdfResourceFunction}<T> {
+  return (resource, options) => {
+    let { context, graph, ignoreRdfType = false, objectSet, preferredLanguages } = (options ?? {});
+    if (!objectSet) { objectSet = new ${syntheticNamePrefix}RdfjsDatasetObjectSet(resource.dataset); };
+    return _fromRdfResourceFunction(resource, { context, graph, ignoreRdfType, objectSet, preferredLanguages });
+  };
+}`);
+//# sourceMappingURL=snippets_wrap_FromRdfResourceFunction.js.map

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

@@ -0,0 +1,3 @@
+import type { SnippetFactory } from "../SnippetFactory.js";
+export declare const snippets_wrap_ToRdfResourceFunction: SnippetFactory;
+//# sourceMappingURL=snippets_wrap_ToRdfResourceFunction.d.ts.map

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

@@ -0,0 +1,14 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_wrap_ToRdfResourceFunction = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}wrap_ToRdfResourceFunction`, code `\
+function ${syntheticNamePrefix}wrap_ToRdfResourceFunction<IdentifierT extends ${imports.Resource}.Identifier, ObjectT extends { ${syntheticNamePrefix}identifier: () => IdentifierT }>(_toRdfResourceFunction: ${snippets._ToRdfResourceFunction}<IdentifierT, ObjectT>): ${snippets.ToRdfResourceFunction}<ObjectT, IdentifierT> {
+  return (object, options) => {
+    let { graph, ignoreRdfType = false, resourceSet } = (options ?? {});
+    if (!resourceSet) {
+      resourceSet = new ${imports.ResourceSet}({ dataFactory: ${imports.dataFactory}, dataset: ${imports.datasetFactory}.dataset() });
+    }
+    const resource = resourceSet.resource(object.${syntheticNamePrefix}identifier());
+    _toRdfResourceFunction({ graph, ignoreRdfType, object, resource, resourceSet });
+    return resource;
+  };
+}`);
+//# sourceMappingURL=snippets_wrap_ToRdfResourceFunction.js.map

package/dist/input/generated.d.ts

@@ -2,6 +2,22 @@ import type { BlankNode, DatasetCore, Literal, NamedNode, Quad_Graph, Variable }
 import { PropertyPath as RdfxResourcePropertyPath, Resource, ResourceSet } from "@rdfx/resource";
 import { NTriplesTerm } from "@rdfx/string";
 import { Either, Maybe } from "purify-ts";
+type $_FromRdfResourceFunction<T> = (resource: Resource, options: {
+    context: undefined | unknown;
+    graph: Exclude<Quad_Graph, Variable> | undefined;
+    ignoreRdfType: boolean;
+    objectSet: $ObjectSet;
+    preferredLanguages: readonly string[] | undefined;
+}) => Either<Error, T>;
+export type $_ToRdfResourceFunction<IdentifierT extends Resource.Identifier, ObjectT extends {
+    $identifier: () => IdentifierT;
+}> = (parameters: {
+    graph: Exclude<Quad_Graph, Variable> | undefined;
+    ignoreRdfType: boolean;
+    object: ObjectT;
+    resource: Resource<IdentifierT>;
+    resourceSet: ResourceSet;
+}) => void;
 interface $BooleanFilter {
     readonly value?: boolean;
 }
@@ -80,13 +96,6 @@ interface $NumericFilter<T> {
     readonly minExclusive?: T;
     readonly minInclusive?: T;
 }
-type $PropertiesFromRdfResourceFunction<T> = (resource: Resource, options: {
-    context: undefined | unknown;
-    graph: Exclude<Quad_Graph, Variable> | undefined;
-    ignoreRdfType: boolean;
-    objectSet: $ObjectSet;
-    preferredLanguages?: readonly string[];
-}) => Either<Error, T>;
 export type $PropertyPath = RdfxResourcePropertyPath;
 export declare namespace $PropertyPath {
     type Filter = object;
@@ -113,11 +122,11 @@ interface $TermFilter {
     readonly languageIn?: readonly string[];
     readonly typeIn?: readonly ("BlankNode" | "Literal" | "NamedNode")[];
 }
-export type $ToRdfResourceFunction<T> = (value: T, options?: {
+export type $ToRdfResourceFunction<ObjectT, IdentifierT extends Resource.Identifier = Resource.Identifier> = (object: ObjectT, options?: {
     graph?: Exclude<Quad_Graph, Variable>;
     ignoreRdfType?: boolean;
     resourceSet?: ResourceSet;
-}) => Resource;
+}) => Resource<IdentifierT>;
 export type $ToRdfResourceValuesFunction<ValueT, ReturnT extends BlankNode | Literal | NamedNode = BlankNode | Literal | NamedNode> = (value: ValueT, options: {
     graph?: Exclude<Quad_Graph, Variable>;
     ignoreRdfType?: boolean;
@@ -252,50 +261,11 @@ export declare namespace PropertyShape {
         readonly uniqueLang?: $MaybeFilter<$BooleanFilter>;
         readonly xone?: $MaybeFilter<$CollectionFilter<$IdentifierFilter>>;
     };
+    const _fromRdfResource: $_FromRdfResourceFunction<PropertyShape>;
     const fromRdfResource: $FromRdfResourceFunction<PropertyShape>;
     const fromRdfResourceValues: $FromRdfResourceValuesFunction<PropertyShape>;
     const fromRdfType: NamedNode<string>;
     function isPropertyShape(object: $Object): object is PropertyShape;
-    const propertiesFromRdfResource: $PropertiesFromRdfResourceFunction<{
-        $identifier: BlankNode | NamedNode;
-        $type: "PropertyShape";
-        and: Maybe<readonly (BlankNode | NamedNode)[]>;
-        classes: readonly NamedNode[];
-        comment: Maybe<string>;
-        datatype: Maybe<NamedNode>;
-        deactivated: Maybe<boolean>;
-        defaultValue: Maybe<NamedNode | Literal>;
-        description: Maybe<string>;
-        display: boolean;
-        flags: readonly string[];
-        groups: readonly (BlankNode | NamedNode)[];
-        hasValues: readonly (NamedNode | Literal)[];
-        in_: Maybe<readonly (NamedNode | Literal)[]>;
-        isDefinedBy: Maybe<BlankNode | NamedNode>;
-        label: Maybe<string>;
-        languageIn: Maybe<readonly string[]>;
-        maxCount: Maybe<bigint>;
-        maxExclusive: Maybe<Literal>;
-        maxInclusive: Maybe<Literal>;
-        maxLength: Maybe<bigint>;
-        minCount: Maybe<bigint>;
-        minExclusive: Maybe<Literal>;
-        minInclusive: Maybe<Literal>;
-        minLength: Maybe<bigint>;
-        mutable: Maybe<boolean>;
-        name: Maybe<string>;
-        node: Maybe<BlankNode | NamedNode>;
-        nodeKind: Maybe<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">>;
-        not: readonly (BlankNode | NamedNode)[];
-        or: Maybe<readonly (BlankNode | NamedNode)[]>;
-        order: Maybe<number>;
-        path: $PropertyPath;
-        patterns: readonly string[];
-        resolve: Maybe<BlankNode | NamedNode>;
-        shaclmateName: Maybe<string>;
-        uniqueLang: Maybe<boolean>;
-        xone: Maybe<readonly (BlankNode | NamedNode)[]>;
-    }>;
     const schema: {
         readonly properties: {
             readonly $identifier: {
@@ -685,8 +655,9 @@ export declare namespace PropertyShape {
             };
         };
     };
-    function toRdfResource(_propertyShape: PropertyShape, options?: Parameters<$ToRdfResourceFunction<PropertyShape>>[1]): Resource;
-    function propertiesToStrings(_propertyShape: PropertyShape): Record<string, string>;
+    const _toRdfResource: $_ToRdfResourceFunction<PropertyShape.Identifier, PropertyShape>;
+    const toRdfResource: $ToRdfResourceFunction<PropertyShape, Identifier>;
+    function _propertiesToStrings(_propertyShape: PropertyShape): Record<string, string>;
     function $toString(this: PropertyShape): string;
     function $toString(_propertyShape: PropertyShape): string;
 }
@@ -713,16 +684,11 @@ export declare namespace PropertyGroup {
         readonly comment?: $MaybeFilter<$StringFilter>;
         readonly label?: $MaybeFilter<$StringFilter>;
     };
+    const _fromRdfResource: $_FromRdfResourceFunction<PropertyGroup>;
     const fromRdfResource: $FromRdfResourceFunction<PropertyGroup>;
     const fromRdfResourceValues: $FromRdfResourceValuesFunction<PropertyGroup>;
     const fromRdfType: NamedNode<string>;
     function isPropertyGroup(object: $Object): object is PropertyGroup;
-    const propertiesFromRdfResource: $PropertiesFromRdfResourceFunction<{
-        $identifier: BlankNode | NamedNode;
-        $type: "PropertyGroup";
-        comment: Maybe<string>;
-        label: Maybe<string>;
-    }>;
     const schema: {
         readonly properties: {
             readonly $identifier: {
@@ -760,8 +726,9 @@ export declare namespace PropertyGroup {
             };
         };
     };
-    function toRdfResource(_propertyGroup: PropertyGroup, options?: Parameters<$ToRdfResourceFunction<PropertyGroup>>[1]): Resource;
-    function propertiesToStrings(_propertyGroup: PropertyGroup): Record<string, string>;
+    const _toRdfResource: $_ToRdfResourceFunction<PropertyGroup.Identifier, PropertyGroup>;
+    const toRdfResource: $ToRdfResourceFunction<PropertyGroup, Identifier>;
+    function _propertiesToStrings(_propertyGroup: PropertyGroup): Record<string, string>;
     function $toString(this: PropertyGroup): string;
     function $toString(_propertyGroup: PropertyGroup): string;
 }
@@ -797,19 +764,11 @@ export declare namespace Ontology {
         readonly tsFeatureIncludes?: $CollectionFilter<$IriFilter>;
         readonly tsImports?: $CollectionFilter<$StringFilter>;
     };
+    const _fromRdfResource: $_FromRdfResourceFunction<Ontology>;
     const fromRdfResource: $FromRdfResourceFunction<Ontology>;
     const fromRdfResourceValues: $FromRdfResourceValuesFunction<Ontology>;
     const fromRdfType: NamedNode<string>;
     function isOntology(object: $Object): object is Ontology;
-    const propertiesFromRdfResource: $PropertiesFromRdfResourceFunction<{
-        $identifier: BlankNode | NamedNode;
-        $type: "Ontology";
-        comment: Maybe<string>;
-        label: Maybe<string>;
-        tsFeatureExcludes: readonly NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_All" | "http://purl.org/shaclmate/ontology#_TsFeature_Create" | "http://purl.org/shaclmate/ontology#_TsFeatures_Default" | "http://purl.org/shaclmate/ontology#_TsFeature_Equals" | "http://purl.org/shaclmate/ontology#_TsFeature_Graphql" | "http://purl.org/shaclmate/ontology#_TsFeature_Hash" | "http://purl.org/shaclmate/ontology#_TsFeature_Json" | "http://purl.org/shaclmate/ontology#_TsFeatures_None" | "http://purl.org/shaclmate/ontology#_TsFeature_Rdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Sparql">[];
-        tsFeatureIncludes: readonly NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_All" | "http://purl.org/shaclmate/ontology#_TsFeature_Create" | "http://purl.org/shaclmate/ontology#_TsFeatures_Default" | "http://purl.org/shaclmate/ontology#_TsFeature_Equals" | "http://purl.org/shaclmate/ontology#_TsFeature_Graphql" | "http://purl.org/shaclmate/ontology#_TsFeature_Hash" | "http://purl.org/shaclmate/ontology#_TsFeature_Json" | "http://purl.org/shaclmate/ontology#_TsFeatures_None" | "http://purl.org/shaclmate/ontology#_TsFeature_Rdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Sparql">[];
-        tsImports: readonly string[];
-    }>;
     const schema: {
         readonly properties: {
             readonly $identifier: {
@@ -879,8 +838,9 @@ export declare namespace Ontology {
             };
         };
     };
-    function toRdfResource(_ontology: Ontology, options?: Parameters<$ToRdfResourceFunction<Ontology>>[1]): Resource;
-    function propertiesToStrings(_ontology: Ontology): Record<string, string>;
+    const _toRdfResource: $_ToRdfResourceFunction<Ontology.Identifier, Ontology>;
+    const toRdfResource: $ToRdfResourceFunction<Ontology, Identifier>;
+    function _propertiesToStrings(_ontology: Ontology): Record<string, string>;
     function $toString(this: Ontology): string;
     function $toString(_ontology: Ontology): string;
 }
@@ -1021,54 +981,11 @@ export declare namespace NodeShape {
         readonly types?: $CollectionFilter<$IriFilter>;
         readonly xone?: $MaybeFilter<$CollectionFilter<$IdentifierFilter>>;
     };
+    const _fromRdfResource: $_FromRdfResourceFunction<NodeShape>;
     const fromRdfResource: $FromRdfResourceFunction<NodeShape>;
     const fromRdfResourceValues: $FromRdfResourceValuesFunction<NodeShape>;
     const fromRdfType: NamedNode<string>;
     function isNodeShape(object: $Object): object is NodeShape;
-    const propertiesFromRdfResource: $PropertiesFromRdfResourceFunction<{
-        $identifier: BlankNode | NamedNode;
-        $type: "NodeShape";
-        and: Maybe<readonly (BlankNode | NamedNode)[]>;
-        classes: readonly NamedNode[];
-        closed: Maybe<boolean>;
-        comment: Maybe<string>;
-        datatype: Maybe<NamedNode>;
-        deactivated: Maybe<boolean>;
-        discriminantValue: Maybe<string>;
-        extern: Maybe<boolean>;
-        flags: readonly string[];
-        fromRdfType: Maybe<NamedNode>;
-        hasValues: readonly (NamedNode | Literal)[];
-        ignoredProperties: Maybe<readonly NamedNode[]>;
-        in_: Maybe<readonly (NamedNode | Literal)[]>;
-        isDefinedBy: Maybe<BlankNode | NamedNode>;
-        label: Maybe<string>;
-        languageIn: Maybe<readonly string[]>;
-        maxCount: Maybe<bigint>;
-        maxExclusive: Maybe<Literal>;
-        maxInclusive: Maybe<Literal>;
-        maxLength: Maybe<bigint>;
-        minCount: Maybe<bigint>;
-        minExclusive: Maybe<Literal>;
-        minInclusive: Maybe<Literal>;
-        minLength: Maybe<bigint>;
-        mutable: Maybe<boolean>;
-        node: Maybe<BlankNode | NamedNode>;
-        nodeKind: Maybe<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">>;
-        not: readonly (BlankNode | NamedNode)[];
-        or: Maybe<readonly (BlankNode | NamedNode)[]>;
-        patterns: readonly string[];
-        properties: readonly (BlankNode | NamedNode)[];
-        rdfType: Maybe<NamedNode>;
-        shaclmateName: Maybe<string>;
-        subClassOf: readonly NamedNode[];
-        toRdfTypes: readonly NamedNode[];
-        tsFeatureExcludes: readonly NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_All" | "http://purl.org/shaclmate/ontology#_TsFeature_Create" | "http://purl.org/shaclmate/ontology#_TsFeatures_Default" | "http://purl.org/shaclmate/ontology#_TsFeature_Equals" | "http://purl.org/shaclmate/ontology#_TsFeature_Graphql" | "http://purl.org/shaclmate/ontology#_TsFeature_Hash" | "http://purl.org/shaclmate/ontology#_TsFeature_Json" | "http://purl.org/shaclmate/ontology#_TsFeatures_None" | "http://purl.org/shaclmate/ontology#_TsFeature_Rdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Sparql">[];
-        tsFeatureIncludes: readonly NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_All" | "http://purl.org/shaclmate/ontology#_TsFeature_Create" | "http://purl.org/shaclmate/ontology#_TsFeatures_Default" | "http://purl.org/shaclmate/ontology#_TsFeature_Equals" | "http://purl.org/shaclmate/ontology#_TsFeature_Graphql" | "http://purl.org/shaclmate/ontology#_TsFeature_Hash" | "http://purl.org/shaclmate/ontology#_TsFeature_Json" | "http://purl.org/shaclmate/ontology#_TsFeatures_None" | "http://purl.org/shaclmate/ontology#_TsFeature_Rdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Sparql">[];
-        tsImports: readonly string[];
-        types: readonly NamedNode[];
-        xone: Maybe<readonly (BlankNode | NamedNode)[]>;
-    }>;
     const schema: {
         readonly properties: {
             readonly $identifier: {
@@ -1507,8 +1424,9 @@ export declare namespace NodeShape {
             };
         };
     };
-    function toRdfResource(_nodeShape: NodeShape, options?: Parameters<$ToRdfResourceFunction<NodeShape>>[1]): Resource;
-    function propertiesToStrings(_nodeShape: NodeShape): Record<string, string>;
+    const _toRdfResource: $_ToRdfResourceFunction<NodeShape.Identifier, NodeShape>;
+    const toRdfResource: $ToRdfResourceFunction<NodeShape, Identifier>;
+    function _propertiesToStrings(_nodeShape: NodeShape): Record<string, string>;
     function $toString(this: NodeShape): string;
     function $toString(_nodeShape: NodeShape): string;
 }