@shaclmate/compiler 4.0.8 → 4.0.10

package/dist/generators/ts/{_ObjectType/ObjectType_toJsonFunctionOrMethodDeclaration.js → _NamedObjectType/NamedObjectType_toJsonFunctionOrMethodDeclaration.js}

@@ -1,7 +1,7 @@
 import { Maybe } from "purify-ts";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectType_toJsonFunctionOrMethodDeclaration() {
+export function NamedObjectType_toJsonFunctionOrMethodDeclaration() {
     if (!this.features.has("json")) {
         return Maybe.empty();
     }
@@ -56,4 +56,4 @@ ${preamble}${syntheticNamePrefix}toJson(${joinCode(parameters, { on: ", " })}):
   return JSON.parse(JSON.stringify({ ${joinCode(jsonObjectMembers, { on: "," })} } satisfies ${this.jsonType().name}));
 }`);
 }
-//# sourceMappingURL=ObjectType_toJsonFunctionOrMethodDeclaration.js.map
+//# sourceMappingURL=NamedObjectType_toJsonFunctionOrMethodDeclaration.js.map

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

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import type { NamedObjectType } from "../NamedObjectType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function NamedObjectType_toRdfResourceFunctionOrMethodDeclaration(this: NamedObjectType): Maybe<Code>;
+//# sourceMappingURL=NamedObjectType_toRdfResourceFunctionOrMethodDeclaration.d.ts.map

package/dist/generators/ts/{_ObjectType/ObjectType_toRdfFunctionOrMethodDeclaration.js → _NamedObjectType/NamedObjectType_toRdfResourceFunctionOrMethodDeclaration.js}

@@ -2,9 +2,10 @@ import { rdf } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
 import { imports } from "../imports.js";
 import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
+import { snippets } from "../snippets.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectType_toRdfFunctionOrMethodDeclaration() {
+export function NamedObjectType_toRdfResourceFunctionOrMethodDeclaration() {
     if (!this.features.has("rdf")) {
         return Maybe.empty();
     }
@@ -17,7 +18,7 @@ export function ObjectType_toRdfFunctionOrMethodDeclaration() {
     if (this.declarationType === "interface") {
         parameters.push(code `${this.thisVariable}: ${this.name}`);
     }
-    parameters.push(code `options?: { ${variables.ignoreRdfType}?: boolean; ${variables.graph}?: Exclude<${imports.Quad_Graph}, ${imports.Variable}>, ${variables.resourceSet}?: ${imports.ResourceSet} }`);
+    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} });`,
     ];
@@ -27,10 +28,10 @@ export function ObjectType_toRdfFunctionOrMethodDeclaration() {
         switch (this.declarationType) {
             case "class":
                 preamble = "override ";
-                superToRdfCall = code `super.${syntheticNamePrefix}toRdf(${superToRdfOptions})`;
+                superToRdfCall = code `super.${syntheticNamePrefix}toRdfResource(${superToRdfOptions})`;
                 break;
             case "interface":
-                superToRdfCall = code `${this.parentObjectTypes[0].staticModuleName}.${syntheticNamePrefix}toRdf(${this.thisVariable}, ${superToRdfOptions})`;
+                superToRdfCall = code `${this.parentObjectTypes[0].staticModuleName}.${syntheticNamePrefix}toRdfResource(${this.thisVariable}, ${superToRdfOptions})`;
                 break;
         }
         statements.push(code `const ${variables.resource} = ${superToRdfCall};`);
@@ -42,17 +43,18 @@ export function ObjectType_toRdfFunctionOrMethodDeclaration() {
         statements.push(code `if (!options?.${variables.ignoreRdfType}) { ${joinCode(this.toRdfTypes.map((toRdfType) => code `${variables.resource}.add(${rdfjsTermExpression(rdf.type)}, ${imports.dataFactory}.namedNode("${toRdfType.value}"), options?.${variables.graph});`), { on: " " })} }`);
     }
     for (const property of this.properties) {
-        statements.push(...property.toRdfStatements({
+        statements.push(...property.toRdfRdfResourceValuesStatements({
             variables: {
-                ...variables,
                 graph: code `options?.${variables.graph}`,
+                resource: variables.resource,
+                resourceSet: variables.resourceSet,
                 value: code `${this.thisVariable}.${property.name}`,
             },
         }));
     }
     statements.push(code `return ${variables.resource};`);
     return Maybe.of(code `\
-${preamble}${syntheticNamePrefix}toRdf(${joinCode(parameters, { on: "," })}): ${this.toRdfjsResourceType} {
+${preamble}${syntheticNamePrefix}toRdfResource(${joinCode(parameters, { on: "," })}): ${this.toRdfjsResourceType} {
   ${joinCode(statements)}
 }`);
 }
@@ -62,4 +64,4 @@ const variables = {
     resource: code `resource`,
     resourceSet: code `resourceSet`,
 };
-//# sourceMappingURL=ObjectType_toRdfFunctionOrMethodDeclaration.js.map
+//# sourceMappingURL=NamedObjectType_toRdfResourceFunctionOrMethodDeclaration.js.map

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

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import type { NamedObjectType } from "../NamedObjectType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration(this: NamedObjectType): Maybe<Code>;
+//# sourceMappingURL=NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration.d.ts.map

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

@@ -0,0 +1,13 @@
+import { Maybe } from "purify-ts";
+import { snippets } from "../snippets.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code } from "../ts-poet-wrapper.js";
+export function NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration() {
+    if (!this.features.has("sparql")) {
+        return Maybe.empty();
+    }
+    return Maybe.of(code `\
+export const ${syntheticNamePrefix}valueSparqlConstructTriples: ${snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}> = ({ filter, ignoreRdfType, valueVariable, variablePrefix }) =>
+  ${this.staticModuleName}.${syntheticNamePrefix}focusSparqlConstructTriples({ filter, focusIdentifier: valueVariable, ignoreRdfType, variablePrefix });`);
+}
+//# sourceMappingURL=NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration.js.map

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

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import type { NamedObjectType } from "../NamedObjectType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function NamedObjectType_valueSparqlWherePatternsFunctionDeclaration(this: NamedObjectType): Maybe<Code>;
+//# sourceMappingURL=NamedObjectType_valueSparqlWherePatternsFunctionDeclaration.d.ts.map

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

@@ -0,0 +1,15 @@
+import { Maybe } from "purify-ts";
+import { snippets } from "../snippets.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code } from "../ts-poet-wrapper.js";
+export function NamedObjectType_valueSparqlWherePatternsFunctionDeclaration() {
+    if (!this.features.has("sparql")) {
+        return Maybe.empty();
+    }
+    return Maybe.of(code `\
+export const ${syntheticNamePrefix}valueSparqlWherePatterns: ${snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}> = ({ filter, ignoreRdfType, preferredLanguages, propertyPatterns, valueVariable, variablePrefix }) =>
+  (propertyPatterns as readonly ${snippets.SparqlPattern}[]).concat(
+    ${this.staticModuleName}.${syntheticNamePrefix}focusSparqlWherePatterns({ filter, focusIdentifier: valueVariable, ignoreRdfType, preferredLanguages, variablePrefix })
+  );`);
+}
+//# sourceMappingURL=NamedObjectType_valueSparqlWherePatternsFunctionDeclaration.js.map

package/dist/generators/ts/{_ObjectType → _NamedObjectType}/Property.d.ts

@@ -1,7 +1,7 @@
 import type { Type } from "../Type.js";
+import type { DiscriminantProperty } from "./DiscriminantProperty.js";
 import type { IdentifierPrefixProperty } from "./IdentifierPrefixProperty.js";
 import type { IdentifierProperty } from "./IdentifierProperty.js";
 import type { ShaclProperty } from "./ShaclProperty.js";
-import type { TypeDiscriminantProperty } from "./TypeDiscriminantProperty.js";
-export type Property = IdentifierProperty | IdentifierPrefixProperty | ShaclProperty<Type> | TypeDiscriminantProperty;
+export type Property = IdentifierProperty | IdentifierPrefixProperty | ShaclProperty<Type> | DiscriminantProperty;
 //# sourceMappingURL=Property.d.ts.map

package/dist/generators/ts/{_ObjectType → _NamedObjectType}/ShaclProperty.d.ts

@@ -29,7 +29,7 @@ export declare class ShaclProperty<TypeT extends Type> extends AbstractProperty<
     get getAccessorDeclaration(): Maybe<Code>;
     get graphqlField(): AbstractProperty<TypeT>["graphqlField"];
     get jsonSignature(): Maybe<Code>;
-    get jsonZodSchema(): AbstractProperty<TypeT>["jsonZodSchema"];
+    get jsonZchema(): AbstractProperty<TypeT>["jsonZchema"];
     protected get schemaObject(): {
         path: Code | undefined;
         kind: Code;
@@ -37,12 +37,12 @@ export declare class ShaclProperty<TypeT extends Type> extends AbstractProperty<
     };
     constructorStatements({ variables, }: Parameters<AbstractProperty<TypeT>["constructorStatements"]>[0]): readonly Code[];
     fromJsonStatements({ variables, }: Parameters<AbstractProperty<TypeT>["fromJsonStatements"]>[0]): readonly Code[];
-    fromRdfExpression({ variables, }: Parameters<AbstractProperty<TypeT>["fromRdfExpression"]>[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>;
     sparqlConstructTriplesExpression({ variables, }: Parameters<AbstractProperty<TypeT>["sparqlConstructTriplesExpression"]>[0]): Maybe<Code>;
     sparqlWherePatternsExpression({ variables, }: Parameters<AbstractProperty<TypeT>["sparqlWherePatternsExpression"]>[0]): ReturnType<AbstractProperty<TypeT>["sparqlWherePatternsExpression"]>;
     toJsonObjectMemberExpression(parameters: Parameters<AbstractProperty<TypeT>["toJsonObjectMemberExpression"]>[0]): Maybe<Code>;
-    toRdfStatements({ variables, }: Parameters<AbstractProperty<TypeT>["toRdfStatements"]>[0]): readonly Code[];
+    toRdfRdfResourceValuesStatements({ variables, }: Parameters<AbstractProperty<TypeT>["toRdfRdfResourceValuesStatements"]>[0]): readonly Code[];
 }
 //# sourceMappingURL=ShaclProperty.d.ts.map

package/dist/generators/ts/{_ObjectType → _NamedObjectType}/ShaclProperty.js

@@ -59,7 +59,7 @@ export class ShaclProperty extends AbstractProperty {
     }
     get declaration() {
         const lhs = [];
-        if (this.objectType.declarationType === "class" &&
+        if (this.namedObjectType.declarationType === "class" &&
             this.visibility !== "public") {
             lhs.push(code `${this.visibility}`);
         }
@@ -103,8 +103,8 @@ export class ShaclProperty extends AbstractProperty {
         const typeJsonType = this.type.jsonType();
         return Maybe.of(code `readonly ${this.name}${typeJsonType.optional ? "?" : ""}: ${typeJsonType.requiredName}`);
     }
-    get jsonZodSchema() {
-        let schema = this.type.jsonZodSchema({
+    get jsonZchema() {
+        let schema = this.type.jsonSchema({
             context: "property",
         });
         this.comment.alt(this.description).ifJust((description) => {
@@ -120,7 +120,7 @@ export class ShaclProperty extends AbstractProperty {
             ...super.schemaObject,
             // comment: this.comment.map(JSON.stringify).extract(),
             // description: this.description.map(JSON.stringify).extract(),
-            path: this.objectType.features.has("rdf")
+            path: this.namedObjectType.features.has("rdf")
                 ? propertyPathToCode(this.path)
                 : undefined,
             // label: this.label.map(JSON.stringify).extract(),
@@ -135,7 +135,7 @@ export class ShaclProperty extends AbstractProperty {
     constructorStatements({ variables, }) {
         const typeConversions = this.type.conversions;
         if (typeConversions.length === 1) {
-            switch (this.objectType.declarationType) {
+            switch (this.namedObjectType.declarationType) {
                 case "class":
                     return [code `this.${this.name} = ${variables.parameter};`];
                 case "interface":
@@ -144,7 +144,7 @@ export class ShaclProperty extends AbstractProperty {
         }
         let lhs;
         const statements = [];
-        switch (this.objectType.declarationType) {
+        switch (this.namedObjectType.declarationType) {
             case "class":
                 lhs = `this.${this.name}`;
                 break;
@@ -164,7 +164,7 @@ export class ShaclProperty extends AbstractProperty {
             code `const ${this.name} = ${this.type.fromJsonExpression({ variables: { value: code `${variables.jsonObject}["${this.name}"]` } })};`,
         ];
     }
-    fromRdfExpression({ variables, }) {
+    fromRdfResourceValuesExpression({ variables, }) {
         // Assume the property has the correct range and ignore the object's RDF type.
         // This also accommodates the case where the object of a property is a dangling identifier that's not the
         // subject of any statements.
@@ -172,11 +172,11 @@ export class ShaclProperty extends AbstractProperty {
             graph: variables.graph,
             resource: variables.resource,
             propertySchema: code `${syntheticNamePrefix}schema.properties.${this.name}`,
-            typeFromRdf: code `((resourceValues) => ${this.type.fromRdfExpression({
+            typeFromRdf: code `((resourceValues) => ${this.type.fromRdfResourceValuesExpression({
                 variables: {
                     ...variables,
                     ignoreRdfType: true,
-                    propertyPath: code `${this.objectType.staticModuleName}.${syntheticNamePrefix}schema.properties.${this.name}.path`,
+                    propertyPath: code `${this.namedObjectType.staticModuleName}.${syntheticNamePrefix}schema.properties.${this.name}.path`,
                     resourceValues: code `resourceValues`,
                 },
             })})`,
@@ -200,7 +200,7 @@ export class ShaclProperty extends AbstractProperty {
             ignoreRdfType: true,
             propertyName: this.name,
             propertySchema: code `${syntheticNamePrefix}schema.properties.${this.name}`,
-            typeSparqlConstructTriples: this.type.sparqlConstructTriplesFunction,
+            typeSparqlConstructTriples: this.type.valueSparqlConstructTriplesFunction,
             variablePrefix: variables.variablePrefix,
         }})`);
     }
@@ -215,7 +215,7 @@ export class ShaclProperty extends AbstractProperty {
                 preferredLanguages: variables.preferredLanguages,
                 propertyName: this.name,
                 propertySchema: code `${syntheticNamePrefix}schema.properties.${this.name}`,
-                typeSparqlWherePatterns: this.type.sparqlWherePatternsFunction,
+                typeSparqlWherePatterns: this.type.valueSparqlWherePatternsFunction,
                 variablePrefix: variables.variablePrefix,
             }})`,
         });
@@ -223,7 +223,7 @@ export class ShaclProperty extends AbstractProperty {
     toJsonObjectMemberExpression(parameters) {
         return Maybe.of(code `${this.name}: ${this.type.toJsonExpression(parameters)}`);
     }
-    toRdfStatements({ variables, }) {
+    toRdfRdfResourceValuesStatements({ variables, }) {
         switch (this.path.termType) {
             case "NamedNode":
                 break;
@@ -237,7 +237,7 @@ export class ShaclProperty extends AbstractProperty {
         }
         const propertyPath = propertyPathToCode(this.path);
         return [
-            code `${variables.resource}.add(${propertyPath}, ${this.type.toRdfExpression({
+            code `${variables.resource}.add(${propertyPath}, ${this.type.toRdfResourceValuesExpression({
                 variables: { ...variables, propertyPath },
             })}, ${variables.graph});`,
         ];
@@ -263,5 +263,5 @@ __decorate([
 ], ShaclProperty.prototype, "jsonSignature", null);
 __decorate([
     Memoize()
-], ShaclProperty.prototype, "jsonZodSchema", null);
+], ShaclProperty.prototype, "jsonZchema", null);
 //# sourceMappingURL=ShaclProperty.js.map

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

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

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

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

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

@@ -0,0 +1,12 @@
+import { imports } from "../imports.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_FocusSparqlConstructTriplesFunction = conditionalOutput(`${syntheticNamePrefix}FocusSparqlConstructTriplesFunction`, code `\
+type ${syntheticNamePrefix}FocusSparqlConstructTriplesFunction<FilterT> = 
+  (parameters: {
+    filter: FilterT | undefined;
+    focusIdentifier: ${imports.NamedNode} | ${imports.Variable};
+    ignoreRdfType: boolean;
+    variablePrefix: string;
+  }) => readonly ${imports.sparqljs}.Triple[];`);
+//# sourceMappingURL=snippets_FocusSparqlConstructTriplesFunction.js.map

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

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

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

@@ -0,0 +1,14 @@
+import { imports } from "../imports.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+import { snippets_SparqlPattern } from "./snippets_SparqlPattern.js";
+export const snippets_FocusSparqlWherePatternsFunction = conditionalOutput(`${syntheticNamePrefix}FocusSparqlWherePatternsFunction`, code `\
+type ${syntheticNamePrefix}FocusSparqlWherePatternsFunction<FilterT> =
+  (parameters: {
+    filter: FilterT | undefined;
+    focusIdentifier: ${imports.NamedNode} | ${imports.Variable};
+    ignoreRdfType: boolean;
+    preferredLanguages: readonly string[] | undefined;
+    variablePrefix: string;
+  }) => readonly ${snippets_SparqlPattern}[];`);
+//# sourceMappingURL=snippets_FocusSparqlWherePatternsFunction.js.map

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,5 @@
+/**
+ * Adapter between generated code and the rdfjs-resource PropertyPath.
+ */
+export declare const snippets_PropertyPath: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+//# sourceMappingURL=snippets_PropertyPath.d.ts.map

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

@@ -0,0 +1,35 @@
+import { imports } from "../imports.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+import { snippets_FromRdfResourceFunction } from "./snippets_FromRdfResourceFunction.js";
+import { snippets_FromRdfResourceValuesFunction } from "./snippets_FromRdfResourceValuesFunction.js";
+import { snippets_ToRdfResourceFunction } from "./snippets_ToRdfResourceFunction.js";
+/**
+ * Adapter between generated code and the rdfjs-resource PropertyPath.
+ */
+export const snippets_PropertyPath = conditionalOutput(`${syntheticNamePrefix}PropertyPath`, code `\
+export type ${syntheticNamePrefix}PropertyPath = ${imports.RdfjsResourcePropertyPath};
+
+export namespace ${syntheticNamePrefix}PropertyPath {
+  export type $Filter = object;
+
+  export function $filter(_filter: $Filter, _value: ${syntheticNamePrefix}PropertyPath): boolean {
+    return true;
+  }
+
+  export const ${syntheticNamePrefix}fromRdfResource: ${snippets_FromRdfResourceFunction}<${syntheticNamePrefix}PropertyPath> = ${imports.RdfjsResourcePropertyPath}.fromResource;
+
+  export const $fromRdfResourceValues: ${snippets_FromRdfResourceValuesFunction}<${syntheticNamePrefix}PropertyPath> = (values, options) =>
+    values.chain((values) =>
+      values.chainMap((value) =>
+        value
+          .toResource()
+          .chain((resource) => ${syntheticNamePrefix}fromRdfResource(resource, options)),
+      ),
+    );
+
+  export const $schema: Readonly<object> = {};
+
+  export const ${syntheticNamePrefix}toRdfResource: ${snippets_ToRdfResourceFunction}<${syntheticNamePrefix}PropertyPath> = ${imports.RdfjsResourcePropertyPath}.toResource;
+}`);
+//# sourceMappingURL=snippets_PropertyPath.js.map

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

@@ -1,10 +1,10 @@
-import { imports } from "../imports.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+import { snippets_PropertyPath } from "./snippets_PropertyPath.js";
 export const snippets_ShaclPropertySchema = conditionalOutput(`${syntheticNamePrefix}ShaclPropertySchema`, code `\
 export interface ${syntheticNamePrefix}ShaclPropertySchema<TypeSchemaT = object> {
   readonly kind: "Shacl";
-  readonly path: ${imports.PropertyPath};
+  readonly path: ${snippets_PropertyPath};
   readonly type: () => TypeSchemaT;
 }`);
 //# sourceMappingURL=snippets_ShaclPropertySchema.js.map

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

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

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

@@ -0,0 +1,7 @@
+import { imports } from "../imports.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_ToRdfResourceFunction = 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};`);
+//# sourceMappingURL=snippets_ToRdfResourceFunction.js.map

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

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

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

@@ -0,0 +1,16 @@
+import { imports } from "../imports.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+import { snippets_PropertyPath } from "./snippets_PropertyPath.js";
+export const snippets_ToRdfResourceValuesFunction = conditionalOutput(`${syntheticNamePrefix}ToRdfResourceValuesFunction`, code `\
+export type ${syntheticNamePrefix}ToRdfResourceValuesFunction<T> =
+  (value: T,
+   options: {
+     graph?: Exclude<${imports.Quad_Graph}, ${imports.Variable}>;
+     ignoreRdfType?: boolean;
+     propertyPath: ${snippets_PropertyPath};
+     resource: ${imports.Resource};
+     resourceSet: ${imports.ResourceSet};
+   }
+  ) => (bigint | boolean | number | string | ${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode})[];`);
+//# sourceMappingURL=snippets_ToRdfResourceValuesFunction.js.map

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

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

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

@@ -0,0 +1,13 @@
+import { imports } from "../imports.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_ValueSparqlConstructTriplesFunction = conditionalOutput(`${syntheticNamePrefix}ValueSparqlConstructTriplesFunction`, code `\
+type ${syntheticNamePrefix}ValueSparqlConstructTriplesFunction<FilterT, SchemaT> = 
+  (parameters: {
+    filter: FilterT | undefined;
+    ignoreRdfType: boolean;
+    schema: SchemaT;
+    valueVariable: ${imports.Variable};
+    variablePrefix: string;
+  }) => readonly ${imports.sparqljs}.Triple[];`);
+//# sourceMappingURL=snippets_ValueSparqlConstructTriplesFunction.js.map

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

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

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

@@ -0,0 +1,16 @@
+import { imports } from "../imports.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+import { snippets_SparqlPattern } from "./snippets_SparqlPattern.js";
+export const snippets_ValueSparqlWherePatternsFunction = conditionalOutput(`${syntheticNamePrefix}ValueSparqlWherePatternsFunction`, code `\
+type ${syntheticNamePrefix}ValueSparqlWherePatternsFunction<FilterT, SchemaT> =
+  (parameters: {
+    filter: FilterT | undefined;
+    ignoreRdfType: boolean;
+    preferredLanguages: readonly string[] | undefined;
+    propertyPatterns: readonly ${snippets_SparqlPattern}[];
+    schema: SchemaT;
+    valueVariable: ${imports.Variable};
+    variablePrefix: string;
+  }) => readonly ${snippets_SparqlPattern}[];`);
+//# sourceMappingURL=snippets_ValueSparqlWherePatternsFunction.js.map

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

@@ -6,9 +6,9 @@ import { snippets_NumericFilter } from "./snippets_NumericFilter.js";
 import { snippets_NumericSchema } from "./snippets_NumericSchema.js";
 import { snippets_SparqlFilterPattern } from "./snippets_SparqlFilterPattern.js";
 import { snippets_SparqlPattern } from "./snippets_SparqlPattern.js";
-import { snippets_SparqlWherePatternsFunctionParameters } from "./snippets_SparqlWherePatternsFunctionParameters.js";
+import { snippets_ValueSparqlWherePatternsFunction } from "./snippets_ValueSparqlWherePatternsFunction.js";
 export const snippets_bigDecimalSparqlWherePatterns = conditionalOutput(`${syntheticNamePrefix}bigDecimalSparqlWherePatterns`, code `\
-function ${syntheticNamePrefix}bigDecimalSparqlWherePatterns({ filter, propertyPatterns, schema, valueVariable }: ${snippets_SparqlWherePatternsFunctionParameters}<${snippets_NumericFilter}<${imports.BigDecimal}>, ${snippets_NumericSchema}<${imports.BigDecimal}>>): readonly ${snippets_SparqlPattern}[] {
+const ${syntheticNamePrefix}bigDecimalSparqlWherePatterns: ${snippets_ValueSparqlWherePatternsFunction}<${snippets_NumericFilter}<${imports.BigDecimal}>, ${snippets_NumericSchema}<${imports.BigDecimal}>> = ({ filter, propertyPatterns, schema, valueVariable }) => {
   const filterPatterns: ${snippets_SparqlFilterPattern}[] = [];
 
   if (filter) {

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

@@ -2,8 +2,8 @@ import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 import { snippets_BlankNodeFilter } from "./snippets_BlankNodeFilter.js";
 import { snippets_BlankNodeSchema } from "./snippets_BlankNodeSchema.js";
-import { snippets_SparqlWherePatternsFunction } from "./snippets_SparqlWherePatternsFunction.js";
+import { snippets_ValueSparqlWherePatternsFunction } from "./snippets_ValueSparqlWherePatternsFunction.js";
 export const snippets_blankNodeSparqlWherePatterns = conditionalOutput(`${syntheticNamePrefix}blankNodeSparqlWherePatterns`, code `\
-const ${syntheticNamePrefix}blankNodeSparqlWherePatterns: ${snippets_SparqlWherePatternsFunction}<${snippets_BlankNodeFilter}, ${snippets_BlankNodeSchema}> =
+const ${syntheticNamePrefix}blankNodeSparqlWherePatterns: ${snippets_ValueSparqlWherePatternsFunction}<${snippets_BlankNodeFilter}, ${snippets_BlankNodeSchema}> =
   ({ propertyPatterns }) => propertyPatterns;`);
 //# sourceMappingURL=snippets_blankNodeSparqlWherePatterns.js.map

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

@@ -1,5 +1,5 @@
-import { code, conditionalOutput } from "ts-poet";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 import { snippets_EqualsResult } from "./snippets_EqualsResult.js";
 export const snippets_booleanEquals = conditionalOutput(`${syntheticNamePrefix}booleanEquals`, code `\
 /**

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

@@ -3,11 +3,11 @@ import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 import { snippets_BooleanFilter } from "./snippets_BooleanFilter.js";
 import { snippets_BooleanSchema } from "./snippets_BooleanSchema.js";
 import { snippets_SparqlFilterPattern } from "./snippets_SparqlFilterPattern.js";
-import { snippets_SparqlWherePatternsFunction } from "./snippets_SparqlWherePatternsFunction.js";
 import { snippets_sparqlValueInPattern } from "./snippets_sparqlValueInPattern.js";
 import { snippets_termSchemaSparqlPatterns } from "./snippets_termSchemaSparqlPatterns.js";
+import { snippets_ValueSparqlWherePatternsFunction } from "./snippets_ValueSparqlWherePatternsFunction.js";
 export const snippets_booleanSparqlWherePatterns = conditionalOutput(`${syntheticNamePrefix}booleanSparqlWherePatterns`, code `\
-const ${syntheticNamePrefix}booleanSparqlWherePatterns: ${snippets_SparqlWherePatternsFunction}<${snippets_BooleanFilter}, ${snippets_BooleanSchema}> =
+const ${syntheticNamePrefix}booleanSparqlWherePatterns: ${snippets_ValueSparqlWherePatternsFunction}<${snippets_BooleanFilter}, ${snippets_BooleanSchema}> =
   ({ filter, valueVariable, ...otherParameters }) => {
     const filterPatterns: ${snippets_SparqlFilterPattern}[] = [];
 

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

@@ -5,10 +5,10 @@ import { snippets_DateSchema } from "./snippets_DateSchema.js";
 import { snippets_literalFactory } from "./snippets_literalFactory.js";
 import { snippets_RdfVocabularies } from "./snippets_RdfVocabularies.js";
 import { snippets_SparqlFilterPattern } from "./snippets_SparqlFilterPattern.js";
-import { snippets_SparqlWherePatternsFunction } from "./snippets_SparqlWherePatternsFunction.js";
 import { snippets_termSchemaSparqlPatterns } from "./snippets_termSchemaSparqlPatterns.js";
+import { snippets_ValueSparqlWherePatternsFunction } from "./snippets_ValueSparqlWherePatternsFunction.js";
 export const snippets_dateSparqlWherePatterns = conditionalOutput(`${syntheticNamePrefix}dateSparqlWherePatterns`, code `\
-const ${syntheticNamePrefix}dateSparqlWherePatterns: ${snippets_SparqlWherePatternsFunction}<${snippets_DateFilter}, ${snippets_DateSchema}> =
+const ${syntheticNamePrefix}dateSparqlWherePatterns: ${snippets_ValueSparqlWherePatternsFunction}<${snippets_DateFilter}, ${snippets_DateSchema}> =
   ({ filter, schema, valueVariable, ...otherParameters }) => {
     const filterPatterns: ${snippets_SparqlFilterPattern}[] = [];
 

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

@@ -2,9 +2,9 @@ import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 import { snippets_DefaultValueSchema } from "./snippets_DefaultValueSchema.js";
 import { snippets_liftSparqlPatterns } from "./snippets_liftSparqlPatterns.js";
-import { snippets_SparqlWherePatternsFunction } from "./snippets_SparqlWherePatternsFunction.js";
+import { snippets_ValueSparqlWherePatternsFunction } from "./snippets_ValueSparqlWherePatternsFunction.js";
 export const snippets_defaultValueSparqlWherePatterns = conditionalOutput(`${syntheticNamePrefix}defaultValueSparqlWherePatterns`, code `\
-function ${syntheticNamePrefix}defaultValueSparqlWherePatterns<ItemFilterT, ItemSchemaT>(itemSparqlWherePatternsFunction: ${snippets_SparqlWherePatternsFunction}<ItemFilterT, ItemSchemaT>): ${snippets_SparqlWherePatternsFunction}<ItemFilterT, ${snippets_DefaultValueSchema}<ItemSchemaT>> {  
+function ${syntheticNamePrefix}defaultValueSparqlWherePatterns<ItemFilterT, ItemSchemaT>(itemSparqlWherePatternsFunction: ${snippets_ValueSparqlWherePatternsFunction}<ItemFilterT, ItemSchemaT>): ${snippets_ValueSparqlWherePatternsFunction}<ItemFilterT, ${snippets_DefaultValueSchema}<ItemSchemaT>> {  
   return ({ schema, ...otherParameters }) => {
     const [itemSparqlWherePatterns, liftSparqlPatterns] = ${snippets_liftSparqlPatterns}(itemSparqlWherePatternsFunction({ ...otherParameters, schema: schema.item() }));
     return [{ patterns: itemSparqlWherePatterns.concat(), type: "optional" }, ...liftSparqlPatterns];

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

@@ -2,7 +2,7 @@ import { imports } from "../imports.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_fromRdfLanguageIn = conditionalOutput(`${syntheticNamePrefix}fromRdfLanguageIn`, code `\
-function ${syntheticNamePrefix}fromRdfLanguageIn( values: ${imports.Resource}.Values, languageIn: readonly string[]): ${imports.Either}<Error, ${imports.Resource}.Values> {
+function ${syntheticNamePrefix}fromRdfLanguageIn(values: ${imports.Resource}.Values, languageIn: readonly string[]): ${imports.Either}<Error, ${imports.Resource}.Values> {
   return values.chainMap(value => value.toLiteral().chain(literal =>
     languageIn.includes(literal.language) ?
       ${imports.Right}(value) :