@shaclmate/compiler 4.0.94 → 4.0.96

package/dist/generators/ts/_ObjectType/{ObjectType_hashFunctionExpression.js → ObjectType_hashFunction.js}

@@ -2,19 +2,16 @@ import { codeEquals } from "../codeEquals.js";
 import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
 const hasherVariable = code `hasher`;
 export function ObjectType_hashFunctionExpression() {
-    let statements = [];
+    return code `(${hasherVariable}, ${this.thisVariable}) => { ${joinCode(this.properties.flatMap((property) => property.hashStatements({
+        variables: {
+            hasher: hasherVariable,
+            object: code `${this.thisVariable}`,
+        },
+    })))} }`;
+}
+export function ObjectType_hashFunctionType() {
     const replacePropertyDeclarations = {};
     for (const property of this.properties) {
-        const propertyHashStatements = property.hashStatements({
-            variables: {
-                hasher: hasherVariable,
-                object: code `${this.thisVariable}`,
-            },
-        });
-        if (propertyHashStatements.length === 0) {
-            continue;
-        }
-        statements = statements.concat(propertyHashStatements);
         const declaration = property.declaration.extract();
         const hashFunctionParameter = property.hashFunctionParameter.extract();
         if (declaration &&
@@ -24,11 +21,10 @@ export function ObjectType_hashFunctionExpression() {
                 code `${hashFunctionParameter}`;
         }
     }
-    statements.push(code `return ${hasherVariable};`);
     let thisTypeExpression = this.expression;
     if (Object.keys(replacePropertyDeclarations).length > 0) {
         thisTypeExpression = code `Omit<${thisTypeExpression}, ${joinCode(Object.keys(replacePropertyDeclarations).map((propertyName) => code `${literalOf(propertyName)}`), { on: " | " })}> & { ${joinCode(Object.values(replacePropertyDeclarations))} }`;
     }
-    return code `<HasherT extends ${this.reusables.snippets.Hasher}>(${hasherVariable}: HasherT, ${this.thisVariable}: ${thisTypeExpression}): HasherT => { ${joinCode(statements)} }`;
+    return code `${this.reusables.snippets.HashFunction}<${thisTypeExpression}>`;
 }
-//# sourceMappingURL=ObjectType_hashFunctionExpression.js.map
+//# sourceMappingURL=ObjectType_hashFunction.js.map

package/dist/generators/ts/_ObjectType/ObjectType_identifierTypeDeclarations.d.ts

@@ -1,4 +1,8 @@
-import type { ObjectType } from "../ObjectType.js";
+import type { BlankNodeType } from "../BlankNodeType.js";
+import type { IdentifierType } from "../IdentifierType.js";
+import type { IriType } from "../IriType.js";
 import { type Code } from "../ts-poet-wrapper.js";
-export declare function ObjectType_identifierTypeDeclarations(this: ObjectType): Record<string, Code>;
+export declare function ObjectType_identifierTypeDeclarations(this: {
+    readonly identifierType: BlankNodeType | IdentifierType | IriType;
+}): Record<string, Code>;
 //# sourceMappingURL=ObjectType_identifierTypeDeclarations.d.ts.map

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

@@ -5,8 +5,7 @@ export function ObjectType_identifierTypeDeclarations() {
     return singleEntryRecord("Identifier", code `\
 export type Identifier = ${this.identifierType.expression};
 export namespace Identifier {
-  export const parse = ${this.identifierType.parseFunction};
-  export const stringify = ${this.identifierType.stringifyFunction};
+  export const parse = ${this.identifierType.parseFunction.annotatedUsage};
 }`);
 }
 //# sourceMappingURL=ObjectType_identifierTypeDeclarations.js.map

package/dist/generators/ts/_ObjectType/ObjectType_sparqlConstructQueryFunction.d.ts

@@ -0,0 +1,20 @@
+import type { Maybe } from "purify-ts";
+import type { Callable } from "../Callable.js";
+import type { CodeThunk } from "../CodeThunk.js";
+import type { Reusables } from "../Reusables.js";
+import type { TsGenerator } from "../TsGenerator.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectType_sparqlConstructQueryFunction(this: {
+    readonly configuration: TsGenerator.Configuration;
+    readonly filterType: Code;
+    _function(parameters: {
+        type: CodeThunk;
+        unannotatedExpression: CodeThunk;
+        unqualifiedName: string;
+    }): Callable;
+    readonly focusSparqlConstructTriplesFunction: Callable;
+    readonly focusSparqlWherePatternsFunction: Callable;
+    readonly name: Maybe<string>;
+    readonly reusables: Reusables;
+}): Callable;
+//# sourceMappingURL=ObjectType_sparqlConstructQueryFunction.d.ts.map

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

@@ -0,0 +1,39 @@
+import { camelCase } from "change-case";
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectType_sparqlConstructQueryFunction() {
+    return this._function({
+        type: code `${this.reusables.snippets.SparqlConstructQueryFunction}<${this.filterType}>`,
+        unannotatedExpression: code `\
+({ filter, ignoreRdfType, preferredLanguages, prefixes, subject, ...queryParameters }) => {
+  const variablePrefix = subject.termType === "Variable" ? subject.value : "${camelCase(this.name.unsafeCoerce())}";
+
+  return {
+    ...queryParameters,
+    prefixes: prefixes ?? {},
+    queryType: "CONSTRUCT",
+    template: (queryParameters.template ?? []).concat(
+      ${this.focusSparqlConstructTriplesFunction.annotatedUsage}({
+        filter,
+        focusIdentifier: subject,
+        ignoreRdfType: !!ignoreRdfType,
+        variablePrefix
+      })
+    ),
+    type: "query",
+    where: (queryParameters.where ?? []).concat(
+      ${this.reusables.snippets.normalizeSparqlWherePatterns}(
+        ${this.focusSparqlWherePatternsFunction.annotatedUsage}({
+          filter,
+          focusIdentifier: subject,
+          ignoreRdfType: !!ignoreRdfType,
+          preferredLanguages,
+          variablePrefix
+        })
+      )
+    )
+  };
+}`,
+        unqualifiedName: "sparqlConstructQuery",
+    });
+}
+//# sourceMappingURL=ObjectType_sparqlConstructQueryFunction.js.map

package/dist/generators/ts/_ObjectType/{ObjectType_sparqlConstructQueryStringFunctionDeclaration.d.ts → ObjectType_sparqlConstructQueryStringFunction.d.ts}

@@ -1,10 +1,17 @@
+import type { Callable } from "../Callable.js";
+import type { CodeThunk } from "../CodeThunk.js";
 import type { Reusables } from "../Reusables.js";
 import type { TsGenerator } from "../TsGenerator.js";
 import { type Code } from "../ts-poet-wrapper.js";
-export declare function ObjectType_sparqlConstructQueryStringFunctionDeclaration(this: {
-    readonly name: string;
+export declare function ObjectType_sparqlConstructQueryStringFunction(this: {
     readonly configuration: TsGenerator.Configuration;
     readonly filterType: Code;
+    _function(parameters: {
+        type: CodeThunk;
+        unannotatedExpression: CodeThunk;
+        unqualifiedName: string;
+    }): Callable;
     readonly reusables: Reusables;
-}): Code;
-//# sourceMappingURL=ObjectType_sparqlConstructQueryStringFunctionDeclaration.d.ts.map
+    readonly sparqlConstructQueryFunction: Callable;
+}): Callable;
+//# sourceMappingURL=ObjectType_sparqlConstructQueryStringFunction.d.ts.map

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

@@ -0,0 +1,11 @@
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectType_sparqlConstructQueryStringFunction() {
+    return this._function({
+        type: code `${this.reusables.snippets.SparqlConstructQueryStringFunction}<${this.filterType}>`,
+        unannotatedExpression: code `\
+(parameters) => new ${this.reusables.imports.sparqljs}.Generator(parameters).stringify(${this.sparqlConstructQueryFunction.annotatedUsage}(parameters));
+`,
+        unqualifiedName: "sparqlConstructQueryString",
+    });
+}
+//# sourceMappingURL=ObjectType_sparqlConstructQueryStringFunction.js.map

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

@@ -0,0 +1,5 @@
+import type { ObjectType } from "../ObjectType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectType_toJsonObjectFunctionExpression(this: ObjectType): Code;
+export declare function ObjectType_toJsonObjectFunctionType(this: ObjectType): Code;
+//# sourceMappingURL=ObjectType_toJsonObjectFunction.d.ts.map

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

@@ -0,0 +1,16 @@
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectType_toJsonObjectFunctionExpression() {
+    const variables = {
+        object: this.thisVariable,
+    };
+    return code `\
+(${this.thisVariable}) => JSON.parse(JSON.stringify({ ${joinCode(this.properties.flatMap((property) => property
+        .toJsonObjectInitializer({
+        variables,
+    })
+        .toList()), { on: "," })} }))`;
+}
+export function ObjectType_toJsonObjectFunctionType() {
+    return code `${this.reusables.snippets.ToJsonObjectFunction}<${this.expression}, ${this.jsonObjectType.expression}>`;
+}
+//# sourceMappingURL=ObjectType_toJsonObjectFunction.js.map

package/dist/generators/ts/_ObjectType/ObjectType_toLoggableFunction.d.ts

@@ -0,0 +1,5 @@
+import type { ObjectType } from "../ObjectType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectType_toLoggableFunctionExpression(this: ObjectType): Code;
+export declare function ObjectType_toLoggableFunctionType(this: ObjectType): Code;
+//# sourceMappingURL=ObjectType_toLoggableFunction.d.ts.map

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

@@ -0,0 +1,11 @@
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectType_toLoggableFunctionExpression() {
+    const variables = {
+        object: this.thisVariable,
+    };
+    return code `(${this.thisVariable}) => ${this.reusables.snippets.compactRecord}({${joinCode(this.properties.flatMap((property) => property.toLoggableInitializer({ variables }).toList()), { on: "," })}})`;
+}
+export function ObjectType_toLoggableFunctionType() {
+    return code `${this.reusables.snippets.ToLoggableFunction}<${this.expression}>`;
+}
+//# sourceMappingURL=ObjectType_toLoggableFunction.js.map

package/dist/generators/ts/_ObjectType/ObjectType_toRdfResourceFunction.d.ts

@@ -0,0 +1,4 @@
+import type { Callable } from "../Callable.js";
+import type { ObjectType } from "../ObjectType.js";
+export declare function ObjectType_toRdfResourceFunction(this: ObjectType): Callable;
+//# sourceMappingURL=ObjectType_toRdfResourceFunction.d.ts.map

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

@@ -0,0 +1,12 @@
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectType_toRdfResourceFunction() {
+    const identifierTypeExpression = this.name
+        .map(() => this.identifierTypeAlias)
+        .orDefault(this.identifierType.expression);
+    return this._function({
+        type: code `${this.reusables.snippets.ToRdfResourceFunction}<${identifierTypeExpression}, ${this.expression}>`,
+        unannotatedExpression: () => code `${this.reusables.snippets.wrap_ToRdfResourceFunction}<${identifierTypeExpression}, ${this.expression}>(${this._toRdfResourceFunction.annotatedUsage})`,
+        unqualifiedName: "toRdfResource",
+    });
+}
+//# sourceMappingURL=ObjectType_toRdfResourceFunction.js.map

package/dist/generators/ts/_ObjectType/ObjectType_toRdfResourceValuesFunction.d.ts

@@ -0,0 +1,5 @@
+import type { ObjectType } from "../ObjectType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectType_toRdfResourceValuesFunctionExpression(this: ObjectType): Code;
+export declare function ObjectType_toRdfResourceValuesFunctionType(this: ObjectType): Code;
+//# sourceMappingURL=ObjectType_toRdfResourceValuesFunction.d.ts.map

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

@@ -0,0 +1,8 @@
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectType_toRdfResourceValuesFunctionExpression() {
+    return code `(value, options) => [${this.toRdfResourceFunction.unannotatedUsage}(value, { graph: options.graph, resourceSet: options.resourceSet }).identifier]`;
+}
+export function ObjectType_toRdfResourceValuesFunctionType() {
+    return code `${this.reusables.snippets.ToRdfResourceValuesFunction}<${this.expression}, ${this.toRdfResourceValueTypesExpression}>`;
+}
+//# sourceMappingURL=ObjectType_toRdfResourceValuesFunction.js.map

package/dist/generators/ts/_ObjectType/{ObjectType_toStringFunctionExpression.d.ts → ObjectType_toStringFunction.d.ts}

@@ -1,4 +1,5 @@
 import type { ObjectType } from "../ObjectType.js";
 import { type Code } from "../ts-poet-wrapper.js";
 export declare function ObjectType_toStringFunctionExpression(this: ObjectType): Code;
-//# sourceMappingURL=ObjectType_toStringFunctionExpression.d.ts.map
+export declare function ObjectType_toStringFunctionType(this: ObjectType): Code;
+//# sourceMappingURL=ObjectType_toStringFunction.d.ts.map

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

@@ -0,0 +1,10 @@
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectType_toStringFunctionExpression() {
+    const expression = code `JSON.stringify(${this.toStringRecordFunction.unannotatedUsage}(${this.thisVariable}))`;
+    return code `(${this.thisVariable}) => ${this.name.map((name) => code `\`${name}(\${${expression}})\``).orDefault(expression)}`;
+}
+export function ObjectType_toStringFunctionType() {
+    const variables = { object: this.thisVariable };
+    return code `${this.reusables.snippets.ToStringFunction}<${this.propertySubsetExpression((property) => property.toStringInitializer({ variables }).isJust())}>`;
+}
+//# sourceMappingURL=ObjectType_toStringFunction.js.map

package/dist/generators/ts/_ObjectType/ObjectType_toStringRecordFunction.d.ts

@@ -0,0 +1,4 @@
+import type { Callable } from "../Callable.js";
+import type { ObjectType } from "../ObjectType.js";
+export declare function ObjectType_toStringRecordFunction(this: ObjectType): Callable;
+//# sourceMappingURL=ObjectType_toStringRecordFunction.d.ts.map

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

@@ -0,0 +1,17 @@
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectType_toStringRecordFunction() {
+    return this._function({
+        type: code `${this.reusables.snippets.ToStringRecordFunction}<${this.propertySubsetExpression((property) => property
+            .toStringInitializer({ variables: { object: code `object` } })
+            .isJust())}>`,
+        unannotatedExpression: () => code `(${this.thisVariable}) => ${this.reusables.snippets.compactRecord}({${joinCode(this.properties.flatMap((property) => property
+            .toStringInitializer({
+            variables: {
+                object: this.thisVariable,
+            },
+        })
+            .toList()), { on: "," })}})`,
+        unqualifiedName: "toStringRecord",
+    });
+}
+//# sourceMappingURL=ObjectType_toStringRecordFunction.js.map

package/dist/generators/ts/_ObjectType/ObjectType_typeGuardFunction.d.ts

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

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

@@ -0,0 +1,18 @@
+import { Maybe } from "purify-ts";
+import { code, literalOf } from "../ts-poet-wrapper.js";
+export function ObjectType_typeGuardFunction() {
+    const discriminatedType = this.discriminatedType.extract();
+    if (!discriminatedType) {
+        return Maybe.empty();
+    }
+    const name = this.name.extract();
+    if (!name) {
+        return Maybe.empty();
+    }
+    return Maybe.of(this._function({
+        type: code `${this.reusables.snippets.ObjectTypeGuardFunction}<${discriminatedType.expression}>`,
+        unannotatedExpression: code `(object): object is ${discriminatedType.expression} => object.${discriminatedType.discriminantProperty.name} === ${literalOf(discriminatedType.discriminantProperty.values[0])}`,
+        unqualifiedName: `is${name}`,
+    }));
+}
+//# sourceMappingURL=ObjectType_typeGuardFunction.js.map

package/dist/generators/ts/_ObjectType/{ObjectType_valueSparqlConstructTriplesFunctionExpression.d.ts → ObjectType_valueSparqlConstructTriplesFunction.d.ts}

@@ -1,4 +1,4 @@
 import type { ObjectType } from "../ObjectType.js";
 import { type Code } from "../ts-poet-wrapper.js";
 export declare function ObjectType_valueSparqlConstructTriplesFunctionExpression(this: ObjectType): Code;
-//# sourceMappingURL=ObjectType_valueSparqlConstructTriplesFunctionExpression.d.ts.map
+//# sourceMappingURL=ObjectType_valueSparqlConstructTriplesFunction.d.ts.map

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

@@ -0,0 +1,7 @@
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectType_valueSparqlConstructTriplesFunctionExpression() {
+    return code `\
+({ filter, ignoreRdfType, valueVariable, variablePrefix }) =>
+  ${this.focusSparqlConstructTriplesFunction.unannotatedUsage}({ filter, focusIdentifier: valueVariable, ignoreRdfType, variablePrefix })`;
+}
+//# sourceMappingURL=ObjectType_valueSparqlConstructTriplesFunction.js.map

package/dist/generators/ts/_ObjectType/{ObjectType_valueSparqlWherePatternsFunctionExpression.d.ts → ObjectType_valueSparqlWherePatternsFunction.d.ts}

@@ -1,4 +1,4 @@
 import type { ObjectType } from "../ObjectType.js";
 import { type Code } from "../ts-poet-wrapper.js";
 export declare function ObjectType_valueSparqlWherePatternsFunctionExpression(this: ObjectType): Code;
-//# sourceMappingURL=ObjectType_valueSparqlWherePatternsFunctionExpression.d.ts.map
+//# sourceMappingURL=ObjectType_valueSparqlWherePatternsFunction.d.ts.map

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

@@ -0,0 +1,9 @@
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectType_valueSparqlWherePatternsFunctionExpression() {
+    return code `\
+({ filter, ignoreRdfType, preferredLanguages, propertyPatterns, valueVariable, variablePrefix }) =>
+  (propertyPatterns as readonly ${this.reusables.snippets.SparqlPattern}[]).concat(
+    ${this.focusSparqlWherePatternsFunction.unannotatedUsage}({ filter, focusIdentifier: valueVariable, ignoreRdfType, preferredLanguages, variablePrefix })
+  )`;
+}
+//# sourceMappingURL=ObjectType_valueSparqlWherePatternsFunction.js.map

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

@@ -1,6 +1,7 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_BooleanSchema = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}BooleanSchema`, code `\
 interface ${syntheticNamePrefix}BooleanSchema<BooleanT extends boolean> {
+  readonly datatype: ${imports.NamedNode};
   readonly hasValues?: readonly ${imports.Literal}[];
   readonly in?: readonly BooleanT[];
   readonly kind: "Boolean";

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

@@ -1,6 +1,7 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_DateSchema = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}DateSchema`, code `\
 interface ${syntheticNamePrefix}DateSchema {
+  readonly datatype: ${imports.NamedNode};
   readonly hasValues?: readonly ${imports.Literal}[];
   readonly in?: readonly Date[];
   readonly kind: "Date" | "DateTime",

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

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

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

@@ -0,0 +1,3 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_FilterFunction = ({ syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}FilterFunction`, code `export type ${syntheticNamePrefix}FilterFunction<FilterT, ValueT> = (filter: FilterT, value: ValueT) => boolean`);
+//# sourceMappingURL=snippets_FilterFunction.js.map

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

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

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

@@ -0,0 +1,21 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_FromJsonObjectFunction = ({ configuration, imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}FromJsonObjectFunction`, code `\
+export type ${syntheticNamePrefix}FromJsonObjectFunction<JsonObjectT extends object, ValueT, ValueSchemaT> = 
+  [ValueSchemaT] extends [undefined]
+  ? (
+      jsonObject: JsonObjectT,
+      options?: {
+        context?: unknown;
+        ${configuration.features.has("ObjectSet") ? code `objectSet?: ${syntheticNamePrefix}ObjectSet;` : ""}
+        schema?: unknown;
+      },
+    ) => ${imports.Either}<Error, ValueT>
+  : (
+      jsonObject: JsonObjectT,
+      options: {
+        context?: unknown;
+        ${configuration.features.has("ObjectSet") ? code `objectSet?: ${syntheticNamePrefix}ObjectSet;` : ""}
+        schema: ValueSchemaT;
+      },
+    ) => ${imports.Either}<Error, ValueT>;`);
+//# sourceMappingURL=snippets_FromJsonObjectFunction.js.map

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

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

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

@@ -0,0 +1,21 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_FromJsonValueFunction = ({ configuration, imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}FromJsonValueFunction`, code `\
+export type ${syntheticNamePrefix}FromJsonValueFunction<JsonValueT, ValueT, ValueSchemaT> = 
+  [ValueSchemaT] extends [undefined]
+  ? (
+      jsonValue: JsonValueT,
+      options?: {
+        context?: unknown;
+        ${configuration.features.has("ObjectSet") ? code `objectSet?: ${syntheticNamePrefix}ObjectSet;` : ""}
+        schema?: unknown;
+      },
+    ) => ${imports.Either}<Error, ValueT>
+  : (
+      jsonValue: JsonValueT,
+      options: {
+        context?: unknown;
+        ${configuration.features.has("ObjectSet") ? code `objectSet?: ${syntheticNamePrefix}ObjectSet;` : ""}
+        schema: ValueSchemaT;
+      },
+    ) => ${imports.Either}<Error, ValueT>;`);
+//# sourceMappingURL=snippets_FromJsonValueFunction.js.map

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

@@ -1,4 +1,4 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_HashFunction = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}HashFunction`, code `\
-export type ${syntheticNamePrefix}HashFunction<HasherT extends ${snippets.Hasher}, ValueT> = (hasher: HasherT, value: ValueT) => HasherT;`);
+export type ${syntheticNamePrefix}HashFunction<ValueT> = (hasher: ${snippets.Hasher}, value: ValueT) => void;`);
 //# sourceMappingURL=snippets_HashFunction.js.map

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

@@ -1,3 +1,3 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_Hasher = ({ syntheticNamePrefix }) => conditionalOutput(`${syntheticNamePrefix}Hasher`, code `type ${syntheticNamePrefix}Hasher = { update: (message: string | number[] | ArrayBuffer | Uint8Array) => void; };`);
+export const snippets_Hasher = ({ syntheticNamePrefix }) => conditionalOutput(`${syntheticNamePrefix}Hasher`, code `export type ${syntheticNamePrefix}Hasher = { update: (message: string | number[] | ArrayBuffer | Uint8Array) => void; };`);
 //# sourceMappingURL=snippets_Hasher.js.map

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

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

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

@@ -0,0 +1,12 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_IdentifierJsonObject = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}IdentifierJsonObject`, code `\
+interface ${syntheticNamePrefix}IdentifierJsonObject<IdT extends string = string> {
+  "@id": IdT;
+}
+  
+namespace ${syntheticNamePrefix}IdentifierJsonObject {
+  export const schema = () => ${imports.z}.object({
+    "@id": ${imports.z}.string().min(1)
+  });
+}`);
+//# sourceMappingURL=snippets_IdentifierJsonObject.js.map

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

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

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

@@ -0,0 +1,14 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_LangStringJsonObject = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}LangStringJsonObject`, code `\
+interface ${syntheticNamePrefix}LangStringJsonObject {
+  "@language": string;
+  "@value": string;
+}
+  
+namespace ${syntheticNamePrefix}LangStringJsonObject {
+  export const schema = () => ${imports.z}.object({
+    "@language": ${imports.z}.string().min(1),
+    "@value": ${imports.z}.string().min(1)
+  });
+}`);
+//# sourceMappingURL=snippets_LangStringJsonObject.js.map

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

@@ -1,5 +1,5 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_Lazy = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}Lazy`, code `\
+export const snippets_Lazy = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}Lazy`, code `\
 /**
  * Type of lazy properties that return a single required value. This is a class instead of an interface so it can be instanceof'd elsewhere.
  */
@@ -15,6 +15,13 @@ export class ${syntheticNamePrefix}Lazy<PartialT, ResolvedT> {
     this.resolver = resolver;
   }
 
+  static fromPartial<PartialT, ResolvedT>(partial: PartialT): ${syntheticNamePrefix}Lazy<PartialT, ResolvedT> {
+    return new ${syntheticNamePrefix}Lazy({
+      partial,
+      resolver: ${snippets.missingResolver}<ResolvedT>
+    });
+  }
+
   resolve(options?: { preferredLanguages?: readonly string[] }): Promise<${imports.Either}<Error, ResolvedT>> {
     return this.resolver(this.partial, options);
   }

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

@@ -1,5 +1,5 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_LazyOption = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}LazyOption`, code `\
+export const snippets_LazyOption = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}LazyOption`, code `\
 /**
  * Type of lazy properties that return a single optional value. This is a class instead of an interface so it can be instanceof'd elsewhere.
  */
@@ -15,6 +15,22 @@ export class ${syntheticNamePrefix}LazyOption<PartialT, ResolvedT> {
     this.resolver = resolver;
   }
 
+  static fromPartial<PartialT, ResolvedT>(partial: PartialT | ${imports.Maybe}<PartialT> | undefined): ${syntheticNamePrefix}LazyOption<PartialT, ResolvedT> {
+    let partialMaybe: ${imports.Maybe}<PartialT>;
+    if (typeof partial === "undefined") {
+      partialMaybe = ${imports.Maybe}.empty();
+    } else if (${imports.Maybe}.isMaybe(partial)) {
+      partialMaybe = partial;
+    } else {
+      partialMaybe = ${imports.Maybe}.of(partial);
+    }
+
+    return new ${syntheticNamePrefix}LazyOption({
+      partial: partialMaybe,
+      resolver: ${snippets.missingResolver}<ResolvedT>
+    });
+  }
+
   async resolve(options?: { preferredLanguages?: readonly string[] }): Promise<${imports.Either}<Error, ${imports.Maybe}<ResolvedT>>> {
     if (this.partial.isNothing()) {
       return ${imports.Right}(${imports.Maybe}.empty());

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

@@ -1,5 +1,5 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_LazySet = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}LazySet`, code `\
+export const snippets_LazySet = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}LazySet`, code `\
 /**
  * Type of lazy properties that return a set of values. This is a class instead of an interface so it can be instanceof'd elsewhere.
  */
@@ -15,6 +15,13 @@ export class ${syntheticNamePrefix}LazySet<PartialT, ResolvedT> {
     this.resolver = resolver;
   }
 
+  static fromPartials<PartialT, ResolvedT>(partials: readonly PartialT[]): ${syntheticNamePrefix}LazySet<PartialT, ResolvedT> {
+    return new ${syntheticNamePrefix}LazySet({
+      partials,
+      resolver: ${snippets.missingResolver}<readonly ResolvedT[]>
+    });
+  }
+
   get length(): number {
     return this.partials.length;
   }

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

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

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

@@ -0,0 +1,16 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_LiteralJsonObject = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}LiteralJsonObject`, code `\
+interface ${syntheticNamePrefix}LiteralJsonObject {
+  "@language"?: string;
+  "@type"?: string;
+  "@value": string;
+}
+  
+namespace ${syntheticNamePrefix}LiteralJsonObject {
+  export const schema = () => ${imports.z}.object({
+    "@language": ${imports.z}.string().min(1).optional(),
+    "@type": ${imports.z}.string().min(1).optional(),
+    "@value": ${imports.z}.string().min(1)
+  });
+}`);
+//# sourceMappingURL=snippets_LiteralJsonObject.js.map

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

@@ -1,6 +1,7 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_NumericSchema = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}NumericSchema`, code `\
 interface ${syntheticNamePrefix}NumericSchema<T> {
+  readonly datatype: ${imports.NamedNode};
   readonly hasValues?: readonly ${imports.Literal}[];
   readonly in?: readonly T[];
   readonly kind: "BigDecimal" | "BigInt" | "Float" | "Int";

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

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

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

@@ -0,0 +1,4 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_ObjectTypeGuardFunction = ({ syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}ObjectTypeGuardFunction`, code `\
+export type ${syntheticNamePrefix}ObjectTypeGuardFunction<ObjectT extends ${syntheticNamePrefix}Object> = (object: ${syntheticNamePrefix}Object) => object is ObjectT;`);
+//# sourceMappingURL=snippets_ObjectTypeGuardFunction.js.map

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

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

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

@@ -0,0 +1,4 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_Primitive = ({ syntheticNamePrefix }) => conditionalOutput(`${syntheticNamePrefix}Primitive`, code `\
+type ${syntheticNamePrefix}Primitive = bigint | boolean | number | string;`);
+//# sourceMappingURL=snippets_Primitive.js.map