@shaclmate/compiler 4.0.97 → 4.0.99

package/dist/generators/ts/_ObjectType/ObjectType_ShaclProperty.js

@@ -6,6 +6,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
+import { SchemaObject } from "../SchemaObject.js";
 import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
 import { tsComment } from "../tsComment.js";
 import { ObjectType_AbstractProperty } from "./ObjectType_AbstractProperty.js";
@@ -106,33 +107,50 @@ export class ObjectType_ShaclProperty extends ObjectType_AbstractProperty {
         });
     }
     get schema() {
-        const initializers = [code `kind: ${literalOf(this.kind)}`];
+        return Maybe.of(this._schema);
+    }
+    get _schema() {
+        // if (
+        //   this.objectType.name.extract() === "DirectRecursiveStruct" ||
+        //   this.objectType.name.extract() === "IndirectRecursiveStruct"
+        // ) {
+        //   console.log("test");
+        // }
+        const properties = {
+            kind: code `kind: ${literalOf(this.kind)}`,
+        };
+        const typeMembers = {
+            kind: code `readonly kind: ${literalOf(this.kind)}`,
+        };
         if (this.configuration.features.has("Object.fromRdf") ||
             this.configuration.features.has("Object.toRdf")) {
-            initializers.push(code `path: ${this.propertyPathToCode(this.path)}`);
+            properties["path"] = code `path: ${this.propertyPathToCode(this.path)}`;
+            typeMembers["path"] =
+                code `readonly path: ${this.reusables.snippets.PropertyPath}`;
         }
         // Use a getter if the type is recursive or the type is an object type, which may have forward references in the file
         if (this.recursive || this.type.referencesNamedType) {
-            initializers.push(code `get type() { return ${this.type.schema}; }`);
+            properties["type"] = () => code `get type() { return ${this.type.schema.expression}; }`;
+            typeMembers["type"] = () => code `readonly type: ${this.type.schema.type.expression}`;
         }
         else {
-            initializers.push(code `type: ${this.type.schema}`);
-        }
-        return Maybe.of(code `{ ${joinCode(initializers, { on: ", " })} }`);
-    }
-    get schemaType() {
-        const initializers = [code `readonly kind: ${literalOf(this.kind)}`];
-        if (this.configuration.features.has("Object.fromRdf") ||
-            this.configuration.features.has("Object.toRdf")) {
-            initializers.push(code `readonly path: ${this.reusables.snippets.PropertyPath}`);
+            properties["type"] = code `type: ${this.type.schema.expression}`;
+            typeMembers["type"] =
+                code `readonly type: ${this.type.schema.type.expression}`;
         }
-        initializers.push(code `readonly type: ${this.type.schemaType}`);
-        return Maybe.of(code `{ ${joinCode(initializers, { on: ", " })} }`);
+        return new SchemaObject({
+            properties,
+            type: new SchemaObject.UserDefinedType({
+                members: typeMembers,
+                name: Maybe.empty(),
+            }),
+            variable: this.schemaVariable,
+        });
     }
     get typeSchemaVariable() {
-        return this.objectType.name
-            .map((name) => code `${name}.schema.properties.${this.name}.type`)
-            .orDefaultLazy(() => this.type.schema);
+        return this.schemaVariable
+            .map((schemaVariable) => code `${schemaVariable}.type`)
+            .orDefaultLazy(() => this.type.schema.expression);
     }
     createInitializer({ variables, }) {
         const parameterVariable = code `${variables.parameters}.${this.name}`;
@@ -169,11 +187,11 @@ export class ObjectType_ShaclProperty extends ObjectType_AbstractProperty {
     }
     fromRdfResourceValuesInitializer({ variables, }) {
         return Maybe.of(code `${this.name}:
-        ${this.reusables.snippets.shaclPropertyFromRdf}<${this.type.expression}, ${this.type.schemaType}>({
+        ${this.reusables.snippets.shaclPropertyFromRdf}<${this.type.expression}, ${this.type.schema.type.expression}>({
           ...${variables.options},
           focusResource: ${variables.focusResource},
           ignoreRdfType: true,
-          propertySchema: ${this.schemaVariable},
+          propertySchema: ${this._schema.expression},
           typeFromRdfResourceValues: ${this.type.fromRdfResourceValuesFunction.unannotatedUsage} 
         })`);
     }
@@ -190,7 +208,7 @@ export class ObjectType_ShaclProperty extends ObjectType_AbstractProperty {
             focusIdentifier: variables.focusIdentifier,
             ignoreRdfType: true,
             propertyName: this.name,
-            propertySchema: this.schemaVariable,
+            propertySchema: this._schema.expression,
             typeSparqlConstructTriples: this.type.valueSparqlConstructTriplesFunction.unannotatedUsage,
             variablePrefix: variables.variablePrefix,
         }})`);
@@ -205,7 +223,7 @@ export class ObjectType_ShaclProperty extends ObjectType_AbstractProperty {
                 ignoreRdfType: true,
                 preferredLanguages: variables.preferredLanguages,
                 propertyName: this.name,
-                propertySchema: this.schemaVariable,
+                propertySchema: this._schema.expression,
                 typeSparqlWherePatterns: this.type.valueSparqlWherePatternsFunction.unannotatedUsage,
                 variablePrefix: variables.variablePrefix,
             }})`,
@@ -231,7 +249,7 @@ export class ObjectType_ShaclProperty extends ObjectType_AbstractProperty {
                 return [];
         }
         const propertyPath = this.objectType.name
-            .map(() => code `${this.schemaVariable}.path`)
+            .map(() => code `${this._schema.expression}.path`)
             .orDefault(this.propertyPathToCode(this.path));
         const { object: objectVariable, ...otherVariables } = variables;
         return [
@@ -281,6 +299,12 @@ __decorate([
 __decorate([
     Memoize()
 ], ObjectType_ShaclProperty.prototype, "jsonObjectMember", null);
+__decorate([
+    Memoize()
+], ObjectType_ShaclProperty.prototype, "schema", null);
+__decorate([
+    Memoize()
+], ObjectType_ShaclProperty.prototype, "_schema", null);
 __decorate([
     Memoize()
 ], ObjectType_ShaclProperty.prototype, "typeSchemaVariable", null);

package/dist/generators/ts/_ObjectType/ObjectType_fromJsonObjectFunction.js

@@ -10,10 +10,15 @@ export function ObjectType_fromJsonObjectFunctionExpression() {
     };
     const propertyInitializers = this.properties.flatMap((property) => property.fromJsonObjectInitializer({ variables }).toList());
     invariant(propertyInitializers.length > 0);
+    let optionsParameter = optionsVariable;
+    this.name.ifNothing(() => {
+        optionsParameter = code `${optionsParameter}: Parameters<${ObjectType_fromJsonObjectFunctionType.call(this)}>[1]`;
+    });
+    optionsParameter = code `${optionsParameter} = {}`;
     return code `\
-(${variables.jsonObject}, ${variables.options} = {}) => ${this.reusables.snippets.sequenceRecord}({ ${joinCode(propertyInitializers, { on: "," })} }).chain(${this.createFunction.annotatedUsage})`;
+(${variables.jsonObject}, ${optionsParameter}) => ${this.reusables.snippets.sequenceRecord}({ ${joinCode(propertyInitializers, { on: "," })} }).chain(${this.createFunction.annotatedUsage})`;
 }
 export function ObjectType_fromJsonObjectFunctionType() {
-    return code `${this.reusables.snippets.FromJsonObjectFunction}<${this.jsonObjectType.expression}, ${this.discriminatedType.map((discriminatedType) => discriminatedType.expression).orDefault(this.expression)}, undefined>`;
+    return code `${this.reusables.snippets.FromJsonFunction}<${this.jsonObjectType.expression}, ${this.discriminatedType.map((discriminatedType) => discriminatedType.expression).orDefault(this.expression)}, undefined>`;
 }
 //# sourceMappingURL=ObjectType_fromJsonObjectFunction.js.map

package/dist/generators/ts/_ObjectType/ObjectType_fromRdfResourceValuesFunction.js

@@ -3,6 +3,6 @@ export function ObjectType_fromRdfResourceValuesFunctionExpression() {
     return code `(values, options) => values.chainMap(value => value.toResource().chain(resource => ${this.fromRdfResourceFunction.annotatedUsage}(resource, options)))`;
 }
 export function ObjectType_fromRdfResourceValuesFunctionType() {
-    return code `${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.discriminatedType.map((discriminatedType) => discriminatedType.expression).orDefault(this.expression)}, ${this.schemaType}>`;
+    return code `${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.discriminatedType.map((discriminatedType) => discriminatedType.expression).orDefault(this.expression)}, ${this.schema.type.expression}>`;
 }
 //# sourceMappingURL=ObjectType_fromRdfResourceValuesFunction.js.map

package/dist/generators/ts/_ObjectType/ObjectType_toJsonObjectFunction.js

@@ -11,6 +11,6 @@ export function ObjectType_toJsonObjectFunctionExpression() {
         .toList()), { on: "," })} }))`;
 }
 export function ObjectType_toJsonObjectFunctionType() {
-    return code `${this.reusables.snippets.ToJsonObjectFunction}<${this.expression}, ${this.jsonObjectType.expression}>`;
+    return code `${this.reusables.snippets.ToJsonFunction}<${this.expression}, ${this.jsonObjectType.expression}>`;
 }
 //# sourceMappingURL=ObjectType_toJsonObjectFunction.js.map

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

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

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

@@ -0,0 +1,28 @@
+import { code, conditionalOutput, joinCode, } from "../ts-poet-wrapper.js";
+export const snippets_FromJsonFunction = ({ configuration, imports, snippets, syntheticNamePrefix, }) => {
+    const options = [code `context?: unknown;`];
+    options.push(code `defaultNamespace?: ${snippets.NamespaceBuilder};`);
+    if (configuration.features.has("ObjectSet")) {
+        options.push(code `objectSet?: ${syntheticNamePrefix}ObjectSet;`);
+    }
+    options.push(code `prefixMap?: ${imports.PrefixMap};`);
+    const joinedOptions = joinCode(options.map((option) => code `        ${option}`), { on: "\n" });
+    return conditionalOutput(`${syntheticNamePrefix}FromJsonFunction`, code `\
+export type ${syntheticNamePrefix}FromJsonFunction<JsonValueT, ValueT, ValueSchemaT> = 
+  [ValueSchemaT] extends [undefined]
+  ? (
+      jsonValue: JsonValueT,
+      options?: {
+${joinedOptions}
+        schema?: unknown;
+      },
+    ) => ${imports.Either}<Error, ValueT>
+  : (
+      jsonValue: JsonValueT,
+      options: {
+${joinedOptions}
+        schema: ValueSchemaT;
+      },
+    ) => ${imports.Either}<Error, ValueT>;`);
+};
+//# sourceMappingURL=snippets_FromJsonFunction.js.map

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

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

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

@@ -0,0 +1,3 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_ToJsonFunction = ({ syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}ToJsonFunction`, code `export type ${syntheticNamePrefix}ToJsonFunction<T, JsonT> = (value: T) => JsonT;`);
+//# sourceMappingURL=snippets_ToJsonFunction.js.map

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

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_arrayFromJsonArray = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}arrayFromJsonArray`, code `\
-function ${syntheticNamePrefix}arrayFromJsonArray<ItemJsonValueT, ItemT, ItemSchemaT>(itemFromJsonValue: ${snippets.FromJsonValueFunction}<ItemJsonValueT, ItemT, ItemSchemaT>): ${snippets.FromJsonValueFunction}<ItemJsonValueT[] | undefined, ItemT[], ${snippets.CollectionSchema}<ItemSchemaT>> {
+function ${syntheticNamePrefix}arrayFromJsonArray<ItemJsonValueT, ItemT, ItemSchemaT>(itemFromJsonValue: ${snippets.FromJsonFunction}<ItemJsonValueT, ItemT, ItemSchemaT>): ${snippets.FromJsonFunction}<ItemJsonValueT[] | undefined, ItemT[], ${snippets.CollectionSchema}<ItemSchemaT>> {
   return (jsonArray, options) => {
     if (jsonArray === undefined) {
       return ${imports.Either}.of([]);

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

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_arrayToJsonArray = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}arrayToJsonArray`, code `\
-function ${syntheticNamePrefix}arrayToJsonArray<ItemT, ItemJsonValueT>(itemToJsonValue: ${snippets.ToJsonValueFunction}<ItemT, ItemJsonValueT>): ${snippets.ToJsonValueFunction}<readonly ItemT[], ItemJsonValueT[]> {
+function ${syntheticNamePrefix}arrayToJsonArray<ItemT, ItemJsonValueT>(itemToJsonValue: ${snippets.ToJsonFunction}<ItemT, ItemJsonValueT>): ${snippets.ToJsonFunction}<readonly ItemT[], ItemJsonValueT[]> {
   return (array) => array.map(itemToJsonValue);
 }`);
 //# sourceMappingURL=snippets_arrayToJsonArray.js.map

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

@@ -1,5 +1,5 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_bigDecimalFromJsonObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}bigDecimalFromJsonObject`, code `\
-const ${syntheticNamePrefix}bigDecimalFromJsonObject: ${snippets.FromJsonObjectFunction}<${snippets.TypedLiteralJsonObject}, ${imports.BigDecimal}, ${snippets.NumericSchema}<${imports.BigDecimal}>> = 
+const ${syntheticNamePrefix}bigDecimalFromJsonObject: ${snippets.FromJsonFunction}<${snippets.TypedLiteralJsonObject}, ${imports.BigDecimal}, ${snippets.NumericSchema}<${imports.BigDecimal}>> = 
   (jsonObject, options) => ${snippets.literalFromJsonObject}(jsonObject, options).chain(${imports.LiteralDecoder}.decodeBigDecimalLiteral);`);
 //# sourceMappingURL=snippets_bigDecimalFromJsonObject.js.map

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

@@ -1,5 +1,5 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_bigDecimalFromJsonString = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}bigDecimalFromJsonString`, code `\
-const ${syntheticNamePrefix}bigDecimalFromJsonString: ${snippets.FromJsonValueFunction}<string, ${imports.BigDecimal}, ${snippets.NumericSchema}<${imports.BigDecimal}>> = 
+const ${syntheticNamePrefix}bigDecimalFromJsonString: ${snippets.FromJsonFunction}<string, ${imports.BigDecimal}, ${snippets.NumericSchema}<${imports.BigDecimal}>> = 
   (jsonValue) => ${imports.Either}.encase(() => new ${imports.BigDecimal}(jsonValue));`);
 //# sourceMappingURL=snippets_bigDecimalFromJsonString.js.map

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

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_bigDecimalToJsonObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}bigDecimalToJsonObject`, code `\
-function ${syntheticNamePrefix}bigDecimalToJsonObject(datatype: ${imports.NamedNode}): ${snippets.ToJsonObjectFunction}<${imports.BigDecimal}, ${snippets.TypedLiteralJsonObject}> {
+function ${syntheticNamePrefix}bigDecimalToJsonObject(datatype: ${imports.NamedNode}): ${snippets.ToJsonFunction}<${imports.BigDecimal}, ${snippets.TypedLiteralJsonObject}> {
   return (value) => ${snippets.typedLiteralToJsonObject}(${snippets.literalFactory}.bigdecimal(value, datatype));
 }`);
 //# sourceMappingURL=snippets_bigDecimalToJsonObject.js.map

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

@@ -1,5 +1,5 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_bigDecimalToJsonString = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}bigDecimalToJsonString`, code `\
-const ${syntheticNamePrefix}bigDecimalToJsonString: ${snippets.ToJsonValueFunction}<${imports.BigDecimal}, string> =
+const ${syntheticNamePrefix}bigDecimalToJsonString: ${snippets.ToJsonFunction}<${imports.BigDecimal}, string> =
   (bigDecimal) => bigDecimal.toFixed();`);
 //# sourceMappingURL=snippets_bigDecimalToJsonString.js.map

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

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_bigIntFromJsonObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}bigIntFromJsonObject`, code `\
-function ${syntheticNamePrefix}bigIntFromJsonObject<BigIntT extends bigint>(jsonObject: ${snippets.TypedLiteralJsonObject}, options: Parameters<${snippets.FromJsonObjectFunction}<${snippets.TypedLiteralJsonObject}, BigIntT, ${snippets.NumericSchema}<BigIntT>>>[1]): ${imports.Either}<Error, BigIntT> {
+function ${syntheticNamePrefix}bigIntFromJsonObject<BigIntT extends bigint>(jsonObject: ${snippets.TypedLiteralJsonObject}, options: Parameters<${snippets.FromJsonFunction}<${snippets.TypedLiteralJsonObject}, BigIntT, ${snippets.NumericSchema}<BigIntT>>>[1]): ${imports.Either}<Error, BigIntT> {
   const { schema } = options;
   return ${snippets.literalFromJsonObject}(jsonObject)
     .chain(${imports.LiteralDecoder}.decodeBigIntLiteral)

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

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_bigIntFromJsonString = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}bigIntFromJsonString`, code `\
-function ${syntheticNamePrefix}bigIntFromJsonString<JsonValueT extends string, BigIntT extends bigint>(jsonValue: JsonValueT, options: Parameters<${snippets.FromJsonValueFunction}<string, BigIntT, ${snippets.NumericSchema}<BigIntT>>>[1]): ${imports.Either}<Error, BigIntT> {
+function ${syntheticNamePrefix}bigIntFromJsonString<JsonValueT extends string, BigIntT extends bigint>(jsonValue: JsonValueT, options: Parameters<${snippets.FromJsonFunction}<string, BigIntT, ${snippets.NumericSchema}<BigIntT>>>[1]): ${imports.Either}<Error, BigIntT> {
   const { schema } = options;
   return ${imports.Either}.encase(() => BigInt(jsonValue) as BigIntT)
     .chain(value => ${snippets.constrainPrimitive}<BigIntT, bigint>(value, schema.in)) as ${imports.Either}<Error, BigIntT>;

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

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_bigIntToJsonObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}bigIntToJsonObject`, code `\
-function ${syntheticNamePrefix}bigIntToJsonObject(datatype: ${imports.NamedNode}): ${snippets.ToJsonObjectFunction}<bigint, ${snippets.TypedLiteralJsonObject}> {
+function ${syntheticNamePrefix}bigIntToJsonObject(datatype: ${imports.NamedNode}): ${snippets.ToJsonFunction}<bigint, ${snippets.TypedLiteralJsonObject}> {
   return (value) => ${snippets.typedLiteralToJsonObject}(${snippets.literalFactory}.bigint(value, datatype));
 }`);
 //# sourceMappingURL=snippets_bigIntToJsonObject.js.map

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

@@ -1,5 +1,5 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_bigIntToJsonString = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}bigIntToJsonString`, code `\
-const ${syntheticNamePrefix}bigIntToJsonString: ${snippets.ToJsonValueFunction}<bigint, string> =
+const ${syntheticNamePrefix}bigIntToJsonString: ${snippets.ToJsonFunction}<bigint, string> =
   (bigInt) => bigInt.toString();`);
 //# sourceMappingURL=snippets_bigIntToJsonString.js.map

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

@@ -1,5 +1,5 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_blankNodeFromJsonObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}blankNodeFromJsonObject`, code `\
-const ${syntheticNamePrefix}blankNodeFromJsonObject: ${snippets.FromJsonObjectFunction}<${snippets.IdentifierJsonObject}, ${imports.BlankNode}, undefined> = 
+const ${syntheticNamePrefix}blankNodeFromJsonObject: ${snippets.FromJsonFunction}<${snippets.IdentifierJsonObject}, ${imports.BlankNode}, undefined> = 
   (jsonObject) => ${snippets.blankNodeFromJsonString}(jsonObject["@id"]);`);
 //# sourceMappingURL=snippets_blankNodeFromJsonObject.js.map

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

@@ -1,5 +1,5 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_blankNodeFromJsonString = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}blankNodeFromJsonString`, code `\
-const ${syntheticNamePrefix}blankNodeFromJsonString: ${snippets.FromJsonValueFunction}<string, ${imports.BlankNode}, undefined> = 
+const ${syntheticNamePrefix}blankNodeFromJsonString: ${snippets.FromJsonFunction}<string, ${imports.BlankNode}, undefined> = 
   (jsonValue) => ${imports.Right}(${imports.dataFactory}.blankNode(jsonValue.substring(2)));`);
 //# sourceMappingURL=snippets_blankNodeFromJsonString.js.map

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

@@ -1,5 +1,5 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_blankNodeToJsonObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}blankNodeToJsonObject`, code `\
-const ${syntheticNamePrefix}blankNodeToJsonObject: ${snippets.ToJsonObjectFunction}<${imports.BlankNode}, ${snippets.IdentifierJsonObject}> =
+const ${syntheticNamePrefix}blankNodeToJsonObject: ${snippets.ToJsonFunction}<${imports.BlankNode}, ${snippets.IdentifierJsonObject}> =
   (blankNode) => ({ "@id": ${snippets.blankNodeToJsonString}(blankNode) });`);
 //# sourceMappingURL=snippets_blankNodeToJsonObject.js.map

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

@@ -1,5 +1,5 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_blankNodeToJsonString = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}blankNodeToJsonString`, code `\
-const ${syntheticNamePrefix}blankNodeToJsonString: ${snippets.ToJsonValueFunction}<${imports.BlankNode}, string> =
+const ${syntheticNamePrefix}blankNodeToJsonString: ${snippets.ToJsonFunction}<${imports.BlankNode}, string> =
   (blankNode) => \`_:\${blankNode.value}\`;`);
 //# sourceMappingURL=snippets_blankNodeToJsonString.js.map

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

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_booleanFromJsonBoolean = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}booleanFromJsonBoolean`, code `\
-function ${syntheticNamePrefix}booleanFromJsonBoolean<BooleanT extends boolean>(jsonBoolean: BooleanT, _options: Parameters<${snippets.FromJsonValueFunction}<BooleanT, BooleanT, ${snippets.BooleanSchema}<BooleanT>>>[1]): ${imports.Either}<Error, BooleanT> {
+function ${syntheticNamePrefix}booleanFromJsonBoolean<BooleanT extends boolean>(jsonBoolean: BooleanT, _options: Parameters<${snippets.FromJsonFunction}<BooleanT, BooleanT, ${snippets.BooleanSchema}<BooleanT>>>[1]): ${imports.Either}<Error, BooleanT> {
   return ${imports.Either}.of(jsonBoolean);
 }`);
 //# sourceMappingURL=snippets_booleanFromJsonBoolean.js.map

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

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_booleanFromJsonObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}booleanFromJsonObject`, code `\
-function ${syntheticNamePrefix}booleanFromJsonObject<BooleanT extends boolean>(jsonObject: ${snippets.TypedLiteralJsonObject}, options: Parameters<${snippets.FromJsonObjectFunction}<${snippets.TypedLiteralJsonObject}, BooleanT, ${snippets.BooleanSchema}<BooleanT>>>[1]): ${imports.Either}<Error, BooleanT> {
+function ${syntheticNamePrefix}booleanFromJsonObject<BooleanT extends boolean>(jsonObject: ${snippets.TypedLiteralJsonObject}, options: Parameters<${snippets.FromJsonFunction}<${snippets.TypedLiteralJsonObject}, BooleanT, ${snippets.BooleanSchema}<BooleanT>>>[1]): ${imports.Either}<Error, BooleanT> {
   const { schema } = options;
   return ${snippets.literalFromJsonObject}(jsonObject)
     .chain(${imports.LiteralDecoder}.decodeBooleanLiteral)

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

@@ -5,7 +5,7 @@ function ${syntheticNamePrefix}convertToIdentifier<DefaultNamespaceT extends ${s
     case "object":
       return ${imports.Either}.of(value);
     case "string":
-      return ${imports.Either}.of(defaultNamespace ? defaultNamespace(value) : ${imports.dataFactory}.namedNode(value));
+      return ${snippets.iriFromString}(value, { defaultNamespace });
     case "undefined":
       return ${imports.Either}.of(${imports.dataFactory}.blankNode());
   }

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

@@ -8,10 +8,8 @@ function ${syntheticNamePrefix}convertToIdentifierProperty<DefaultNamespaceT ext
       const captureIdentifier = identifier;
       return ${imports.Either}.of(() => captureIdentifier);
     }
-    case "string": {
-      const captureIdentifier = defaultNamespace ? defaultNamespace(identifier) : ${imports.dataFactory}.namedNode(identifier);
-      return ${imports.Either}.of(() => captureIdentifier);
-    }
+    case "string":
+      return ${snippets.iriFromString}(identifier, { defaultNamespace }).map(iri => (() => iri));
     case "undefined": {
       const captureIdentifier = ${imports.dataFactory}.blankNode();
       return ${imports.Either}.of(() => captureIdentifier);

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

@@ -5,7 +5,7 @@ function ${syntheticNamePrefix}convertToIri<DefaultNamespaceT extends ${snippets
     case "object":
       return ${imports.Either}.of(value);
     case "string":
-      return ${imports.Either}.of(defaultNamespace ? defaultNamespace(value) : ${imports.dataFactory}.namedNode(value));
+      return ${snippets.iriFromString}(value, { defaultNamespace });
   }
 }`);
 //# sourceMappingURL=snippets_convertToIri.js.map

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

@@ -9,8 +9,7 @@ function ${syntheticNamePrefix}convertToIriIdentifierProperty<DefaultNamespaceT
       return ${imports.Either}.of(() => captureIdentifier);
     }
     case "string": {
-      const captureIdentifier = defaultNamespace ? defaultNamespace(identifier) : ${imports.dataFactory}.namedNode(identifier);
-      return ${imports.Either}.of(() => captureIdentifier);
+      return ${snippets.iriFromString}(identifier, { defaultNamespace }).map(iri => (() => iri));
     }
   }
 }`);

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

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

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

@@ -0,0 +1,11 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_convertToIriLiteral = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToIriLiteral`, code `\
+function ${syntheticNamePrefix}convertToIriLiteral<IriT extends string>(value: IriT | ${imports.NamedNode}<IriT>, _defaultNamespace?: ${snippets.NamespaceBuilder}): ${imports.Either}<Error, ${imports.NamedNode}<IriT>> {
+  switch (typeof value) {
+    case "object":
+      return ${imports.Either}.of(value);
+    case "string":
+      return ${imports.Either}.of(${imports.dataFactory}.namedNode<IriT>(value));
+  }
+}`);
+//# sourceMappingURL=snippets_convertToIriLiteral.js.map

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

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

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

@@ -0,0 +1,17 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_convertToIriLiteralIdentifierProperty = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToIriLiteralIdentifierProperty`, code `\
+function ${syntheticNamePrefix}convertToIriLiteralIdentifierProperty<InIriT extends string>(identifier: (() => ${imports.NamedNode}<InIriT>) | ${imports.NamedNode}<InIriT> | InIriT, _defaultNamespace?: ${snippets.NamespaceBuilder}): ${imports.Either}<Error, (() => ${imports.NamedNode}<InIriT>)> {
+  switch (typeof identifier) {
+    case "function":
+      return ${imports.Either}.of(identifier);
+    case "object": {
+      const captureIdentifier = identifier;
+      return ${imports.Either}.of(() => captureIdentifier);
+    }
+    case "string": {
+      const captureIdentifier = ${imports.dataFactory}.namedNode<InIriT>(identifier);
+      return ${imports.Either}.of(() => captureIdentifier);
+    }
+  }
+}`);
+//# sourceMappingURL=snippets_convertToIriLiteralIdentifierProperty.js.map

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

@@ -1,5 +1,5 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_dateFromJsonObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}dateFromJsonObject`, code `\
-const ${syntheticNamePrefix}dateFromJsonObject: ${snippets.FromJsonObjectFunction}<${snippets.TypedLiteralJsonObject}, Date, undefined> = 
+const ${syntheticNamePrefix}dateFromJsonObject: ${snippets.FromJsonFunction}<${snippets.TypedLiteralJsonObject}, Date, undefined> = 
   (jsonObject) => ${snippets.literalFromJsonObject}(jsonObject).chain(${imports.LiteralDecoder}.decodeDateLiteral);`);
 //# sourceMappingURL=snippets_dateFromJsonObject.js.map

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

@@ -1,5 +1,5 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_dateFromJsonString = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}dateFromJsonString`, code `\
-const ${syntheticNamePrefix}dateFromJsonString: ${snippets.FromJsonValueFunction}<string, Date, ${snippets.DateSchema}> = 
+const ${syntheticNamePrefix}dateFromJsonString: ${snippets.FromJsonFunction}<string, Date, ${snippets.DateSchema}> = 
   (jsonValue) => ${imports.Either}.encase(() => new Date(jsonValue));`);
 //# sourceMappingURL=snippets_dateFromJsonString.js.map

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

@@ -1,5 +1,5 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_dateTimeFromJsonObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}dateTimeFromJsonObject`, code `\
-const ${syntheticNamePrefix}dateTimeFromJsonObject: ${snippets.FromJsonObjectFunction}<${snippets.TypedLiteralJsonObject}, Date, undefined> = 
+const ${syntheticNamePrefix}dateTimeFromJsonObject: ${snippets.FromJsonFunction}<${snippets.TypedLiteralJsonObject}, Date, undefined> = 
   (jsonObject) => ${snippets.literalFromJsonObject}(jsonObject).chain(${imports.LiteralDecoder}.decodeDateTimeLiteral);`);
 //# sourceMappingURL=snippets_dateTimeFromJsonObject.js.map

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

@@ -1,5 +1,5 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_dateTimeToJsonString = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}dateTimeToJsonString`, code `\
-const ${syntheticNamePrefix}dateTimeToJsonString: ${snippets.ToJsonValueFunction}<Date, string> =
+const ${syntheticNamePrefix}dateTimeToJsonString: ${snippets.ToJsonFunction}<Date, string> =
   (date) => date.toISOString();`);
 //# sourceMappingURL=snippets_dateTimeToJsonString.js.map

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

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_dateToJsonObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}dateToJsonObject`, code `\
-function ${syntheticNamePrefix}dateToJsonObject(datatype: ${imports.NamedNode}): ${snippets.ToJsonObjectFunction}<Date, ${snippets.TypedLiteralJsonObject}> {
+function ${syntheticNamePrefix}dateToJsonObject(datatype: ${imports.NamedNode}): ${snippets.ToJsonFunction}<Date, ${snippets.TypedLiteralJsonObject}> {
   return (value) => ${snippets.typedLiteralToJsonObject}(${snippets.literalFactory}.date(value, datatype));
 }`);
 //# sourceMappingURL=snippets_dateToJsonObject.js.map

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

@@ -1,5 +1,5 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_dateToJsonString = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}dateToJsonString`, code `\
-const ${syntheticNamePrefix}dateToJsonString: ${snippets.ToJsonValueFunction}<Date, string> =
+const ${syntheticNamePrefix}dateToJsonString: ${snippets.ToJsonFunction}<Date, string> =
   (date) => ${snippets.toIsoDateString}(date);`);
 //# sourceMappingURL=snippets_dateToJsonString.js.map

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

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_defaultValueFromJsonObject = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}defaultValueFromJsonObject`, code `\
-function ${syntheticNamePrefix}defaultValueFromJsonObject<ItemJsonObjectT extends object, ItemT, ItemSchemaT>(itemFromJsonObject: ${snippets.FromJsonObjectFunction}<ItemJsonObjectT, ItemT, ItemSchemaT>): ${snippets.FromJsonObjectFunction}<ItemJsonObjectT, ItemT, ${snippets.DefaultValueSchema}<ItemSchemaT>> {
+function ${syntheticNamePrefix}defaultValueFromJsonObject<ItemJsonObjectT extends object, ItemT, ItemSchemaT>(itemFromJsonObject: ${snippets.FromJsonFunction}<ItemJsonObjectT, ItemT, ItemSchemaT>): ${snippets.FromJsonFunction}<ItemJsonObjectT, ItemT, ${snippets.DefaultValueSchema}<ItemSchemaT>> {
   return (jsonObject, options) => {
     const { schema, ...otherOptions } = options;
     return itemFromJsonObject(jsonObject, { schema: schema.itemType, ...otherOptions });

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

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_defaultValueFromJsonValue = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}defaultValueFromJsonValue`, code `\
-function ${syntheticNamePrefix}defaultValueFromJsonValue<ItemJsonValueT, ItemT, ItemSchemaT>(itemFromJsonValue: ${snippets.FromJsonValueFunction}<ItemJsonValueT, ItemT, ItemSchemaT>): ${snippets.FromJsonValueFunction}<ItemJsonValueT, ItemT, ${snippets.DefaultValueSchema}<ItemSchemaT>> {
+function ${syntheticNamePrefix}defaultValueFromJsonValue<ItemJsonValueT, ItemT, ItemSchemaT>(itemFromJsonValue: ${snippets.FromJsonFunction}<ItemJsonValueT, ItemT, ItemSchemaT>): ${snippets.FromJsonFunction}<ItemJsonValueT, ItemT, ${snippets.DefaultValueSchema}<ItemSchemaT>> {
   return (jsonValue, options) => {
     const { schema, ...otherOptions } = options;
     return itemFromJsonValue(jsonValue, { schema: schema.itemType, ...otherOptions });

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

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_floatFromJsonNumber = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}floatFromJsonNumber`, code `\
-function ${syntheticNamePrefix}floatFromJsonNumber<FloatT extends number>(jsonNumber: FloatT, _options: Parameters<${snippets.FromJsonValueFunction}<FloatT, FloatT, ${snippets.NumericSchema}<FloatT>>>[1]): ${imports.Either}<Error, FloatT> {
+function ${syntheticNamePrefix}floatFromJsonNumber<FloatT extends number>(jsonNumber: FloatT, _options: Parameters<${snippets.FromJsonFunction}<FloatT, FloatT, ${snippets.NumericSchema}<FloatT>>>[1]): ${imports.Either}<Error, FloatT> {
   return ${imports.Either}.of(jsonNumber);
 }`);
 //# sourceMappingURL=snippets_floatFromJsonNumber.js.map

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

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_floatFromJsonObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}floatFromJsonObject`, code `\
-function ${syntheticNamePrefix}floatFromJsonObject<FloatT extends number>(jsonObject: ${snippets.TypedLiteralJsonObject}, options: Parameters<${snippets.FromJsonObjectFunction}<${snippets.TypedLiteralJsonObject}, FloatT, ${snippets.NumericSchema}<FloatT>>>[1]): ${imports.Either}<Error, FloatT> {
+function ${syntheticNamePrefix}floatFromJsonObject<FloatT extends number>(jsonObject: ${snippets.TypedLiteralJsonObject}, options: Parameters<${snippets.FromJsonFunction}<${snippets.TypedLiteralJsonObject}, FloatT, ${snippets.NumericSchema}<FloatT>>>[1]): ${imports.Either}<Error, FloatT> {
   const { schema } = options;
   return ${snippets.literalFromJsonObject}(jsonObject)
     .chain(${imports.LiteralDecoder}.decodeFloatLiteral)

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

@@ -1,5 +1,5 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_identifierFromJsonObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}identifierFromJsonObject`, code `\
-const ${syntheticNamePrefix}identifierFromJsonObject: ${snippets.FromJsonObjectFunction}<${snippets.IdentifierJsonObject}, ${imports.BlankNode} | ${imports.NamedNode}, ${snippets.IdentifierSchema}> = 
+const ${syntheticNamePrefix}identifierFromJsonObject: ${snippets.FromJsonFunction}<${snippets.IdentifierJsonObject}, ${imports.BlankNode} | ${imports.NamedNode}, ${snippets.IdentifierSchema}> = 
   (jsonObject, options) => ${snippets.identifierFromJsonString}(jsonObject["@id"], options);`);
 //# sourceMappingURL=snippets_identifierFromJsonObject.js.map

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

@@ -1,5 +1,5 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_identifierFromJsonString = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}identifierFromJsonString`, code `\
-const ${syntheticNamePrefix}identifierFromJsonString: ${snippets.FromJsonValueFunction}<string, ${imports.BlankNode} | ${imports.NamedNode}, ${snippets.IdentifierSchema}> = 
+const ${syntheticNamePrefix}identifierFromJsonString: ${snippets.FromJsonFunction}<string, ${imports.BlankNode} | ${imports.NamedNode}, ${snippets.IdentifierSchema}> = 
   (jsonString, options) => jsonString.startsWith("_:") ? ${snippets.blankNodeFromJsonString}(jsonString, options) as ${imports.Either}<Error, ${imports.BlankNode} | ${imports.NamedNode}> : ${snippets.iriFromJsonString}(jsonString, options) as ${imports.Either}<Error, ${imports.BlankNode} | ${imports.NamedNode}>;`);
 //# sourceMappingURL=snippets_identifierFromJsonString.js.map

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

@@ -1,5 +1,5 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_identifierToJsonObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}identifierToJsonObject`, code `\
-const ${syntheticNamePrefix}identifierToJsonObject: ${snippets.ToJsonObjectFunction}<${imports.BlankNode} | ${imports.NamedNode}, ${snippets.IdentifierJsonObject}> =
+const ${syntheticNamePrefix}identifierToJsonObject: ${snippets.ToJsonFunction}<${imports.BlankNode} | ${imports.NamedNode}, ${snippets.IdentifierJsonObject}> =
   (identifier) => identifier.termType === "BlankNode" ? ${snippets.blankNodeToJsonObject}(identifier) : ${snippets.iriToJsonObject}(identifier);`);
 //# sourceMappingURL=snippets_identifierToJsonObject.js.map

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

@@ -1,5 +1,5 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_identifierToJsonString = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}identifierToJsonString`, code `\
-const ${syntheticNamePrefix}identifierToJsonString: ${snippets.ToJsonValueFunction}<${imports.BlankNode} | ${imports.NamedNode}, string> =
+const ${syntheticNamePrefix}identifierToJsonString: ${snippets.ToJsonFunction}<${imports.BlankNode} | ${imports.NamedNode}, string> =
   (identifier) => identifier.termType === "BlankNode" ? ${snippets.blankNodeToJsonString}(identifier) : ${snippets.iriToJsonString}(identifier);`);
 //# sourceMappingURL=snippets_identifierToJsonString.js.map

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

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_intFromJsonNumber = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}intFromJsonNumber`, code `\
-function ${syntheticNamePrefix}intFromJsonNumber<IntT extends number>(jsonNumber: IntT, _options: Parameters<${snippets.FromJsonValueFunction}<IntT, IntT, ${snippets.NumericSchema}<IntT>>>[1]): ${imports.Either}<Error, IntT> {
+function ${syntheticNamePrefix}intFromJsonNumber<IntT extends number>(jsonNumber: IntT, _options: Parameters<${snippets.FromJsonFunction}<IntT, IntT, ${snippets.NumericSchema}<IntT>>>[1]): ${imports.Either}<Error, IntT> {
   return ${imports.Either}.of(jsonNumber);
 }`);
 //# sourceMappingURL=snippets_intFromJsonNumber.js.map

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

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_intFromJsonObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}intFromJsonObject`, code `\
-function ${syntheticNamePrefix}intFromJsonObject<IntT extends number>(jsonObject: ${snippets.TypedLiteralJsonObject}, options: Parameters<${snippets.FromJsonObjectFunction}<${snippets.TypedLiteralJsonObject}, IntT, ${snippets.NumericSchema}<IntT>>>[1]): ${imports.Either}<Error, IntT> {
+function ${syntheticNamePrefix}intFromJsonObject<IntT extends number>(jsonObject: ${snippets.TypedLiteralJsonObject}, options: Parameters<${snippets.FromJsonFunction}<${snippets.TypedLiteralJsonObject}, IntT, ${snippets.NumericSchema}<IntT>>>[1]): ${imports.Either}<Error, IntT> {
   const { schema } = options;
   return ${snippets.literalFromJsonObject}(jsonObject)
     .chain(${imports.LiteralDecoder}.decodeIntLiteral)