@shaclmate/compiler 4.0.78 → 4.0.80

package/dist/generators/ts/{_DiscriminatedUnionType/DiscriminatedUnionType_Discriminant.d.ts → _AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_Discriminant.d.ts}

@@ -1,6 +1,6 @@
 import type { AbstractType } from "../AbstractType.js";
 import type { Typeof } from "../Typeof.js";
-export type DiscriminatedUnionType_Discriminant = ExtrinsicDiscriminant | HybridDiscriminant | IntrinsicDiscriminant | TypeofDiscriminant;
+export type AbstractDiscriminatedUnionType_Discriminant = ExtrinsicDiscriminant | HybridDiscriminant | IntrinsicDiscriminant | TypeofDiscriminant;
 type ExtrinsicDiscriminant = {
     readonly jsonName: string;
     readonly kind: "Extrinsic";
@@ -27,4 +27,4 @@ type TypeofDiscriminant = {
     readonly memberValues: readonly Typeof[];
 };
 export {};
-//# sourceMappingURL=DiscriminatedUnionType_Discriminant.d.ts.map
+//# sourceMappingURL=AbstractDiscriminatedUnionType_Discriminant.d.ts.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_Discriminant.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=AbstractDiscriminatedUnionType_Discriminant.js.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_conversionFunctionExpression.d.ts

@@ -0,0 +1,6 @@
+import { Maybe } from "purify-ts";
+import type { AbstractDiscriminatedUnionType } from "../AbstractDiscriminatedUnionType.js";
+import { AbstractType } from "../AbstractType.js";
+import type { Type } from "../Type.js";
+export declare function AbstractDiscriminatedUnionType_conversionFunctionExpression<MemberTypeT extends Type>(this: AbstractDiscriminatedUnionType<MemberTypeT>): Maybe<AbstractType.ConversionFunction>;
+//# sourceMappingURL=AbstractDiscriminatedUnionType_conversionFunctionExpression.d.ts.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_conversionFunctionExpression.js

@@ -0,0 +1,86 @@
+import { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
+import { AbstractType } from "../AbstractType.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function AbstractDiscriminatedUnionType_conversionFunctionExpression() {
+    if (this.discriminant.kind === "Typeof") {
+        // If the members are discriminated by typeof, they can all be used as source types.
+        return Maybe.of({
+            code: code `${this.reusables.snippets.identityConversionFunction}`,
+            sourceTypes: this.members.flatMap(({ type }) => type.jsTypes.map((jsType) => ({
+                expression: type.expression,
+                jsType,
+            }))),
+        });
+    }
+    if (this.discriminant.kind === "Intrinsic") {
+        // Allow discriminated unions with intrinsic discriminants (e.g., a "termType" property) to accept additional
+        // source types with typeofs besides "object".
+        // @rdfx/builder relies on discriminated unions of IRI | SomeObjectType and forces SomeObjectType to use the discriminant property
+        // "termType" so the two members share it. These properties should accept (keyof DefaultNamespaceT & string) | NamedNode | SomeObjectType source types --
+        // the "string" typeof for IRI and then "object" identity typeofs for the IRI and SomeObjectType, respectively.
+        const memberIdentitySourceTypes = [];
+        const otherMemberConversionsByTypeof = new Map();
+        for (const member of this.members) {
+            const memberConversionFunction = member.type.conversionFunction.extract();
+            const memberIdentitySourceType = {
+                expression: member.type.expression,
+                jsType: {
+                    instanceof: "Object",
+                    typeof: "object",
+                },
+            };
+            memberIdentitySourceTypes.push(memberIdentitySourceType);
+            if (!memberConversionFunction) {
+                // Identity conversion
+                continue;
+            }
+            const memberSourceTypes = memberConversionFunction.sourceTypes;
+            invariant(memberSourceTypes.length > 1, "member type should return Maybe.empty() instead of returning an identity conversion alone");
+            let haveMemberIdentitySourceType = false;
+            for (const memberSourceType of memberSourceTypes) {
+                if (AbstractType.ConversionFunction.SourceType.equals(memberSourceType, memberIdentitySourceType)) {
+                    haveMemberIdentitySourceType = true;
+                    continue;
+                }
+                if (memberSourceType.jsType.typeof === "object") {
+                    this.logger.debug("%s: member type %s conversion function has more than one source type with typeof === 'object'", this, member.type);
+                    return Maybe.empty();
+                }
+                if (otherMemberConversionsByTypeof.has(memberSourceType.jsType.typeof)) {
+                    this.logger.debug("%s: member type %s conversion function has a source type with the same non-object typeof as another member type", this, member.type);
+                    return Maybe.empty();
+                }
+                otherMemberConversionsByTypeof.set(memberSourceType.jsType.typeof, [
+                    memberSourceType,
+                    memberConversionFunction,
+                ]);
+            }
+            invariant(haveMemberIdentitySourceType, "member conversion source types should include the member type itself");
+        }
+        invariant(memberIdentitySourceTypes.length === this.members.length);
+        if (otherMemberConversionsByTypeof.size === 0) {
+            return Maybe.empty();
+        }
+        const otherMemberConversions = [...otherMemberConversionsByTypeof.values()];
+        const sourceTypes = memberIdentitySourceTypes.concat([
+            ...otherMemberConversions.map((_) => _[0]),
+        ]);
+        const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
+        return Maybe.of({
+            code: code `\
+(<${syntheticNamePrefix}DefaultNamespaceT extends ${this.reusables.snippets.NamespaceBuilder} = ${this.reusables.snippets.NamespaceBuilder}>(value: ${joinCode(sourceTypes.map((sourceType) => sourceType.expression), { on: " | " })}, defaultNamespace?: ${syntheticNamePrefix}DefaultNamespaceT): ${this.reusables.imports.Either}<Error, ${this.expression}> => {
+  switch (typeof value) {
+    case "object": return ${this.reusables.imports.Either}.of(value);
+    ${joinCode(otherMemberConversions.map(([otherMemberSourceType, otherMemberConversionFunction]) => code `case "${otherMemberSourceType.jsType.typeof}": return ${otherMemberConversionFunction.code}(value, defaultNamespace);`), { on: "\n" })}
+    default:
+      value satisfies never;
+      throw new Error("should never reach this point");
+  }
+})`,
+            sourceTypes,
+        });
+    }
+    return Maybe.empty();
+}
+//# sourceMappingURL=AbstractDiscriminatedUnionType_conversionFunctionExpression.js.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_equalsFunctionExpression.d.ts

@@ -0,0 +1,5 @@
+import type { AbstractDiscriminatedUnionType } from "../AbstractDiscriminatedUnionType.js";
+import type { Type } from "../Type.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function AbstractDiscriminatedUnionType_equalsFunctionExpression<MemberTypeT extends Type>(this: AbstractDiscriminatedUnionType<MemberTypeT>): Code;
+//# sourceMappingURL=AbstractDiscriminatedUnionType_equalsFunctionExpression.d.ts.map

package/dist/generators/ts/{_DiscriminatedUnionType/DiscriminatedUnionType_equalsFunctionExpression.js → _AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_equalsFunctionExpression.js}

@@ -1,5 +1,5 @@
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function DiscriminatedUnionType_equalsFunctionExpression() {
+export function AbstractDiscriminatedUnionType_equalsFunctionExpression() {
     return code `\
 ((left: ${this.expression}, right: ${this.expression}) => {
 ${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeCheck(code `left`)} && ${typeCheck(code `right`)}) {
@@ -9,4 +9,4 @@ ${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeChe
   return ${this.reusables.imports.Left}({ left, right, propertyName: "type", propertyValuesUnequal: { left: typeof left, right: typeof right, type: "boolean" as const }, type: "property" as const });
 })`;
 }
-//# sourceMappingURL=DiscriminatedUnionType_equalsFunctionExpression.js.map
+//# sourceMappingURL=AbstractDiscriminatedUnionType_equalsFunctionExpression.js.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_filterFunctionExpression.d.ts

@@ -0,0 +1,5 @@
+import type { AbstractDiscriminatedUnionType } from "../AbstractDiscriminatedUnionType.js";
+import type { Type } from "../Type.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function AbstractDiscriminatedUnionType_filterFunctionExpression<MemberTypeT extends Type>(this: AbstractDiscriminatedUnionType<MemberTypeT>): Code;
+//# sourceMappingURL=AbstractDiscriminatedUnionType_filterFunctionExpression.d.ts.map

package/dist/generators/ts/{_DiscriminatedUnionType/DiscriminatedUnionType_filterFunctionExpression.js → _AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_filterFunctionExpression.js}

@@ -1,5 +1,5 @@
 import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
-export function DiscriminatedUnionType_filterFunctionExpression() {
+export function AbstractDiscriminatedUnionType_filterFunctionExpression() {
     const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
     return code `\
 ((filter: ${this.filterType}, value: ${this.expression}) => {
@@ -21,4 +21,4 @@ if (filter.on?.[${literalOf(primaryDiscriminantValue)}] !== undefined && ${typeC
   return true;
 })`;
 }
-//# sourceMappingURL=DiscriminatedUnionType_filterFunctionExpression.js.map
+//# sourceMappingURL=AbstractDiscriminatedUnionType_filterFunctionExpression.js.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_filterTypeExpression.d.ts

@@ -0,0 +1,5 @@
+import type { AbstractDiscriminatedUnionType } from "../AbstractDiscriminatedUnionType.js";
+import type { Type } from "../Type.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function AbstractDiscriminatedUnionType_filterTypeExpression<MemberTypeT extends Type>(this: AbstractDiscriminatedUnionType<MemberTypeT>): Code;
+//# sourceMappingURL=AbstractDiscriminatedUnionType_filterTypeExpression.d.ts.map

package/dist/generators/ts/{_DiscriminatedUnionType/DiscriminatedUnionType_filterTypeExpression.js → _AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_filterTypeExpression.js}

@@ -1,5 +1,5 @@
 import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
-export function DiscriminatedUnionType_filterTypeExpression() {
+export function AbstractDiscriminatedUnionType_filterTypeExpression() {
     const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
     return code `\
   {
@@ -7,4 +7,4 @@ export function DiscriminatedUnionType_filterTypeExpression() {
    readonly on?: { ${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `readonly ${literalOf(primaryDiscriminantValue)}?: ${type.filterType}`), { on: ";" })} }
   }`;
 }
-//# sourceMappingURL=DiscriminatedUnionType_filterTypeExpression.js.map
+//# sourceMappingURL=AbstractDiscriminatedUnionType_filterTypeExpression.js.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_fromJsonFunctionExpression.d.ts

@@ -0,0 +1,5 @@
+import type { AbstractDiscriminatedUnionType } from "../AbstractDiscriminatedUnionType.js";
+import type { Type } from "../Type.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function AbstractDiscriminatedUnionType_fromJsonFunctionExpression<MemberTypeT extends Type>(this: AbstractDiscriminatedUnionType<MemberTypeT>): Code;
+//# sourceMappingURL=AbstractDiscriminatedUnionType_fromJsonFunctionExpression.d.ts.map

package/dist/generators/ts/{_DiscriminatedUnionType/DiscriminatedUnionType_fromJsonFunctionExpression.js → _AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_fromJsonFunctionExpression.js}

@@ -1,5 +1,5 @@
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function DiscriminatedUnionType_fromJsonFunctionExpression() {
+export function AbstractDiscriminatedUnionType_fromJsonFunctionExpression() {
     return code `\
 ((value: ${this.jsonType().expression}): ${this.reusables.imports.Either}<Error, ${this.expression}> => {
 ${joinCode(this.members.map(({ jsonType, jsonTypeCheck, type, unwrap, wrap }) => code `if (${jsonTypeCheck(code `value`)}) { return ${type.fromJsonExpression({
@@ -11,4 +11,4 @@ ${joinCode(this.members.map(({ jsonType, jsonTypeCheck, type, unwrap, wrap }) =>
   throw new Error("unable to deserialize JSON");
 })`;
 }
-//# sourceMappingURL=DiscriminatedUnionType_fromJsonFunctionExpression.js.map
+//# sourceMappingURL=AbstractDiscriminatedUnionType_fromJsonFunctionExpression.js.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_fromRdfResourceValuesFunctionExpression.d.ts

@@ -0,0 +1,5 @@
+import type { AbstractDiscriminatedUnionType } from "../AbstractDiscriminatedUnionType.js";
+import type { Type } from "../Type.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function AbstractDiscriminatedUnionType_fromRdfResourceValuesFunctionExpression<MemberTypeT extends Type>(this: AbstractDiscriminatedUnionType<MemberTypeT>): Code;
+//# sourceMappingURL=AbstractDiscriminatedUnionType_fromRdfResourceValuesFunctionExpression.d.ts.map

package/dist/generators/ts/{_DiscriminatedUnionType/DiscriminatedUnionType_fromRdfResourceValuesFunctionExpression.js → _AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_fromRdfResourceValuesFunctionExpression.js}

@@ -1,5 +1,5 @@
 import { code, literalOf } from "../ts-poet-wrapper.js";
-export function DiscriminatedUnionType_fromRdfResourceValuesFunctionExpression() {
+export function AbstractDiscriminatedUnionType_fromRdfResourceValuesFunctionExpression() {
     return code `\
 (((values, options) =>
   values.chainMap(value => {
@@ -19,4 +19,4 @@ export function DiscriminatedUnionType_fromRdfResourceValuesFunctionExpression()
   })
 ) satisfies ${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.expression}, ${this.schemaType}>)`;
 }
-//# sourceMappingURL=DiscriminatedUnionType_fromRdfResourceValuesFunctionExpression.js.map
+//# sourceMappingURL=AbstractDiscriminatedUnionType_fromRdfResourceValuesFunctionExpression.js.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_hashFunctionExpression.d.ts

@@ -0,0 +1,5 @@
+import type { AbstractDiscriminatedUnionType } from "../AbstractDiscriminatedUnionType.js";
+import type { Type } from "../Type.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function AbstractDiscriminatedUnionType_hashFunctionExpression<MemberTypeT extends Type>(this: AbstractDiscriminatedUnionType<MemberTypeT>): Code;
+//# sourceMappingURL=AbstractDiscriminatedUnionType_hashFunctionExpression.d.ts.map

package/dist/generators/ts/{_DiscriminatedUnionType/DiscriminatedUnionType_hashFunctionExpression.js → _AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_hashFunctionExpression.js}

@@ -1,9 +1,9 @@
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function DiscriminatedUnionType_hashFunctionExpression() {
+export function AbstractDiscriminatedUnionType_hashFunctionExpression() {
     return code `\
 (<HasherT extends ${this.reusables.snippets.Hasher}>(hasher: HasherT, value: ${this.expression}): HasherT => {
 ${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeCheck(code `value`)}) { return ${type.hashFunction}(hasher, ${unwrap(code `value`)}); }`))}
   return hasher;
 })`;
 }
-//# sourceMappingURL=DiscriminatedUnionType_hashFunctionExpression.js.map
+//# sourceMappingURL=AbstractDiscriminatedUnionType_hashFunctionExpression.js.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_inferDiscriminant.d.ts

@@ -0,0 +1,8 @@
+import type { Maybe } from "purify-ts";
+import type { AbstractDiscriminatedUnionType } from "../AbstractDiscriminatedUnionType.js";
+import type { Type } from "../Type.js";
+export declare function AbstractDiscriminatedUnionType_inferDiscriminant<MemberTypeT extends Type>(this: AbstractDiscriminatedUnionType<MemberTypeT>, members: readonly {
+    readonly discriminantValue: Maybe<number | string>;
+    readonly type: Type;
+}[]): AbstractDiscriminatedUnionType.Discriminant;
+//# sourceMappingURL=AbstractDiscriminatedUnionType_inferDiscriminant.d.ts.map

package/dist/generators/ts/{_DiscriminatedUnionType/DiscriminatedUnionType_inferDiscriminant.js → _AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_inferDiscriminant.js}

@@ -11,7 +11,7 @@ function termTypes(type) {
             return emptyTermTypesSet;
     }
 }
-export function DiscriminatedUnionType_inferDiscriminant(members) {
+export function AbstractDiscriminatedUnionType_inferDiscriminant(members) {
     // extrinsic with user-specified values
     if (members.some((member) => member.discriminantValue.isJust())) {
         return {
@@ -130,4 +130,4 @@ export function DiscriminatedUnionType_inferDiscriminant(members) {
     }
 }
 const emptyTermTypesSet = new Set();
-//# sourceMappingURL=DiscriminatedUnionType_inferDiscriminant.js.map
+//# sourceMappingURL=AbstractDiscriminatedUnionType_inferDiscriminant.js.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_inlineExpression.d.ts

@@ -0,0 +1,5 @@
+import type { AbstractDiscriminatedUnionType } from "../AbstractDiscriminatedUnionType.js";
+import type { Type } from "../Type.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function AbstractDiscriminatedUnionType_inlineExpression<MemberTypeT extends Type>(this: AbstractDiscriminatedUnionType<MemberTypeT>): Code;
+//# sourceMappingURL=AbstractDiscriminatedUnionType_inlineExpression.d.ts.map

package/dist/generators/ts/{_DiscriminatedUnionType/DiscriminatedUnionType_inlineExpression.js → _AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_inlineExpression.js}

@@ -1,5 +1,5 @@
 import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
-export function DiscriminatedUnionType_inlineExpression() {
+export function AbstractDiscriminatedUnionType_inlineExpression() {
     const discriminant = this.discriminant; // To get type narrowing to work
     switch (discriminant.kind) {
         case "Extrinsic":
@@ -28,4 +28,4 @@ export function DiscriminatedUnionType_inlineExpression() {
             throw new Error("should never reach this point");
     }
 }
-//# sourceMappingURL=DiscriminatedUnionType_inlineExpression.js.map
+//# sourceMappingURL=AbstractDiscriminatedUnionType_inlineExpression.js.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_jsonSchemaExpression.d.ts

@@ -0,0 +1,5 @@
+import type { AbstractDiscriminatedUnionType } from "../AbstractDiscriminatedUnionType.js";
+import type { Type } from "../Type.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function AbstractDiscriminatedUnionType_jsonSchemaExpression<MemberTypeT extends Type>(this: AbstractDiscriminatedUnionType<MemberTypeT>): Code;
+//# sourceMappingURL=AbstractDiscriminatedUnionType_jsonSchemaExpression.d.ts.map

package/dist/generators/ts/{_DiscriminatedUnionType/DiscriminatedUnionType_jsonSchemaExpression.js → _AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_jsonSchemaExpression.js}

@@ -1,5 +1,5 @@
 import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
-export function DiscriminatedUnionType_jsonSchemaExpression() {
+export function AbstractDiscriminatedUnionType_jsonSchemaExpression() {
     const discriminant = this.discriminant; // To get type narrowing to work
     switch (discriminant.kind) {
         case "Extrinsic":
@@ -29,4 +29,4 @@ export function DiscriminatedUnionType_jsonSchemaExpression() {
             throw discriminant;
     }
 }
-//# sourceMappingURL=DiscriminatedUnionType_jsonSchemaExpression.js.map
+//# sourceMappingURL=AbstractDiscriminatedUnionType_jsonSchemaExpression.js.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_jsonTypeLiteral.d.ts

@@ -0,0 +1,5 @@
+import type { AbstractDiscriminatedUnionType } from "../AbstractDiscriminatedUnionType.js";
+import { AbstractType } from "../AbstractType.js";
+import type { Type } from "../Type.js";
+export declare function AbstractDiscriminatedUnionType_jsonTypeLiteral<MemberTypeT extends Type>(this: AbstractDiscriminatedUnionType<MemberTypeT>): AbstractType.JsonType;
+//# sourceMappingURL=AbstractDiscriminatedUnionType_jsonTypeLiteral.d.ts.map

package/dist/generators/ts/{_DiscriminatedUnionType/DiscriminatedUnionType_jsonTypeLiteral.js → _AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_jsonTypeLiteral.js}

@@ -1,6 +1,6 @@
 import { AbstractType } from "../AbstractType.js";
 import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
-export function DiscriminatedUnionType_jsonTypeLiteral() {
+export function AbstractDiscriminatedUnionType_jsonTypeLiteral() {
     const discriminant = this.discriminant; // To get type narrowing to work
     switch (discriminant.kind) {
         case "Extrinsic":
@@ -23,4 +23,4 @@ export function DiscriminatedUnionType_jsonTypeLiteral() {
             throw discriminant;
     }
 }
-//# sourceMappingURL=DiscriminatedUnionType_jsonTypeLiteral.js.map
+//# sourceMappingURL=AbstractDiscriminatedUnionType_jsonTypeLiteral.js.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_schemaTypeExpression.d.ts

@@ -0,0 +1,5 @@
+import type { AbstractDiscriminatedUnionType } from "../AbstractDiscriminatedUnionType.js";
+import type { Type } from "../Type.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function AbstractDiscriminatedUnionType_schemaTypeExpression<MemberTypeT extends Type>(this: AbstractDiscriminatedUnionType<MemberTypeT>): Code;
+//# sourceMappingURL=AbstractDiscriminatedUnionType_schemaTypeExpression.d.ts.map

package/dist/generators/ts/{_DiscriminatedUnionType/DiscriminatedUnionType_schemaTypeExpression.js → _AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_schemaTypeExpression.js}

@@ -1,5 +1,5 @@
 import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
-export function DiscriminatedUnionType_schemaTypeExpression() {
+export function AbstractDiscriminatedUnionType_schemaTypeExpression() {
     return code `${{
         kind: this.kind,
         members: code `{ ${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `readonly ${literalOf(primaryDiscriminantValue)}: ${{
@@ -8,4 +8,4 @@ export function DiscriminatedUnionType_schemaTypeExpression() {
         }}`), { on: ";" })} }`,
     }}`;
 }
-//# sourceMappingURL=DiscriminatedUnionType_schemaTypeExpression.js.map
+//# sourceMappingURL=AbstractDiscriminatedUnionType_schemaTypeExpression.js.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_toJsonFunctionExpression.d.ts

@@ -0,0 +1,5 @@
+import type { AbstractDiscriminatedUnionType } from "../AbstractDiscriminatedUnionType.js";
+import type { Type } from "../Type.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function AbstractDiscriminatedUnionType_toJsonFunctionExpression<MemberTypeT extends Type>(this: AbstractDiscriminatedUnionType<MemberTypeT>): Code;
+//# sourceMappingURL=AbstractDiscriminatedUnionType_toJsonFunctionExpression.d.ts.map

package/dist/generators/ts/{_DiscriminatedUnionType/DiscriminatedUnionType_toJsonFunctionExpression.js → _AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_toJsonFunctionExpression.js}

@@ -1,5 +1,5 @@
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function DiscriminatedUnionType_toJsonFunctionExpression() {
+export function AbstractDiscriminatedUnionType_toJsonFunctionExpression() {
     return code `\
 ((value: ${this.expression}): ${this.jsonType().expression} => {
 ${joinCode(this.members.map(({ typeCheck, typeToJsonExpression, unwrap, wrap }) => code `if (${typeCheck(code `value`)}) { return ${wrap(typeToJsonExpression(unwrap(code `value`)))}; }`))}
@@ -7,4 +7,4 @@ ${joinCode(this.members.map(({ typeCheck, typeToJsonExpression, unwrap, wrap })
   throw new Error("unable to serialize to JSON");
 })`;
 }
-//# sourceMappingURL=DiscriminatedUnionType_toJsonFunctionExpression.js.map
+//# sourceMappingURL=AbstractDiscriminatedUnionType_toJsonFunctionExpression.js.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_toRdfResourceValuesFunctionExpression.d.ts

@@ -0,0 +1,5 @@
+import type { AbstractDiscriminatedUnionType } from "../AbstractDiscriminatedUnionType.js";
+import type { Type } from "../Type.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function AbstractDiscriminatedUnionType_toRdfResourceValuesFunctionExpression<MemberTypeT extends Type>(this: AbstractDiscriminatedUnionType<MemberTypeT>): Code;
+//# sourceMappingURL=AbstractDiscriminatedUnionType_toRdfResourceValuesFunctionExpression.d.ts.map

package/dist/generators/ts/{_DiscriminatedUnionType/DiscriminatedUnionType_toRdfResourceValuesFunctionExpression.js → _AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_toRdfResourceValuesFunctionExpression.js}

@@ -1,5 +1,5 @@
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function DiscriminatedUnionType_toRdfResourceValuesFunctionExpression() {
+export function AbstractDiscriminatedUnionType_toRdfResourceValuesFunctionExpression() {
     return code `\
   (((value, _options): (${joinCode([...this.toRdfResourceValueTypes].map((toRdfResourceValueType) => {
         switch (toRdfResourceValueType) {
@@ -27,4 +27,4 @@ export function DiscriminatedUnionType_toRdfResourceValuesFunctionExpression() {
     throw new Error("unable to serialize to RDF");
   }) satisfies ${this.reusables.snippets.ToRdfResourceValuesFunction}<${this.expression}>)`;
 }
-//# sourceMappingURL=DiscriminatedUnionType_toRdfResourceValuesFunctionExpression.js.map
+//# sourceMappingURL=AbstractDiscriminatedUnionType_toRdfResourceValuesFunctionExpression.js.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_toStringFunctionExpression.d.ts

@@ -0,0 +1,5 @@
+import type { AbstractDiscriminatedUnionType } from "../AbstractDiscriminatedUnionType.js";
+import type { Type } from "../Type.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function AbstractDiscriminatedUnionType_toStringFunctionExpression<MemberTypeT extends Type>(this: AbstractDiscriminatedUnionType<MemberTypeT>): Code;
+//# sourceMappingURL=AbstractDiscriminatedUnionType_toStringFunctionExpression.d.ts.map

package/dist/generators/ts/{_DiscriminatedUnionType/DiscriminatedUnionType_toStringFunctionExpression.js → _AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_toStringFunctionExpression.js}

@@ -1,5 +1,5 @@
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function DiscriminatedUnionType_toStringFunctionExpression() {
+export function AbstractDiscriminatedUnionType_toStringFunctionExpression() {
     return code `\
 ((value: ${this.expression}): string => {
 ${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeCheck(code `value`)}) { return ${type.toStringExpression({
@@ -9,4 +9,4 @@ ${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeChe
   throw new Error("unable to serialize to string");
 })`;
 }
-//# sourceMappingURL=DiscriminatedUnionType_toStringFunctionExpression.js.map
+//# sourceMappingURL=AbstractDiscriminatedUnionType_toStringFunctionExpression.js.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression.d.ts

@@ -0,0 +1,5 @@
+import type { AbstractDiscriminatedUnionType } from "../AbstractDiscriminatedUnionType.js";
+import type { Type } from "../Type.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function AbstractDiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression<MemberTypeT extends Type>(this: AbstractDiscriminatedUnionType<MemberTypeT>): Code;
+//# sourceMappingURL=AbstractDiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression.d.ts.map

package/dist/generators/ts/{_DiscriminatedUnionType/DiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression.js → _AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression.js}

@@ -1,5 +1,5 @@
 import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
-export function DiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression() {
+export function AbstractDiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression() {
     return code `\
 ((({ ignoreRdfType, filter, schema, ...otherParameters }) => {
   let triples: ${this.reusables.imports.sparqljs}.Triple[] = [];
@@ -10,4 +10,4 @@ triples = triples.concat(${type.valueSparqlConstructTriplesFunction}({ ...otherP
   return triples;
 }) satisfies ${this.reusables.snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}>)`;
 }
-//# sourceMappingURL=DiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression.js.map
+//# sourceMappingURL=AbstractDiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression.js.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression.d.ts

@@ -0,0 +1,5 @@
+import type { AbstractDiscriminatedUnionType } from "../AbstractDiscriminatedUnionType.js";
+import type { Type } from "../Type.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function AbstractDiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression<MemberTypeT extends Type>(this: AbstractDiscriminatedUnionType<MemberTypeT>): Code;
+//# sourceMappingURL=AbstractDiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression.d.ts.map

package/dist/generators/ts/{_DiscriminatedUnionType/DiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression.js → _AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression.js}

@@ -1,5 +1,5 @@
 import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
-export function DiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression() {
+export function AbstractDiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression() {
     return code `\
 ((({ filter, schema, ...otherParameters }) => {
   const unionPatterns: ${this.reusables.imports.sparqljs}.GroupPattern[] = [];
@@ -10,4 +10,4 @@ unionPatterns.push({ patterns: ${type.valueSparqlWherePatternsFunction}({ ...oth
   return [{ patterns: unionPatterns, type: "union" }];
 }) satisfies ${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}>)`;
 }
-//# sourceMappingURL=DiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression.js.map
+//# sourceMappingURL=AbstractDiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression.js.map

package/dist/generators/ts/_AbstractType/AbstractType_ConversionFunction.d.ts

@@ -1,10 +1,16 @@
 import type { Code } from "../ts-poet-wrapper.js";
-import type { AbstractType_JsType } from "./AbstractType_JsType.js";
+import { AbstractType_JsType } from "./AbstractType_JsType.js";
 export interface AbstractType_ConversionFunction {
     readonly code: Code;
-    readonly sourceTypes: {
+    readonly sourceTypes: AbstractType_ConversionFunction.SourceType[];
+}
+export declare namespace AbstractType_ConversionFunction {
+    interface SourceType {
         readonly expression: Code;
         readonly jsType: AbstractType_JsType;
-    }[];
+    }
+    namespace SourceType {
+        function equals(left: SourceType, right: SourceType): boolean;
+    }
 }
 //# sourceMappingURL=AbstractType_ConversionFunction.d.ts.map

package/dist/generators/ts/_AbstractType/AbstractType_ConversionFunction.js

@@ -1,2 +1,19 @@
-export {};
+import { codeEquals } from "../codeEquals.js";
+import { AbstractType_JsType } from "./AbstractType_JsType.js";
+export var AbstractType_ConversionFunction;
+(function (AbstractType_ConversionFunction) {
+    let SourceType;
+    (function (SourceType) {
+        function equals(left, right) {
+            if (!codeEquals(left.expression, right.expression)) {
+                return false;
+            }
+            if (!AbstractType_JsType.equals(left.jsType, right.jsType)) {
+                return false;
+            }
+            return true;
+        }
+        SourceType.equals = equals;
+    })(SourceType = AbstractType_ConversionFunction.SourceType || (AbstractType_ConversionFunction.SourceType = {}));
+})(AbstractType_ConversionFunction || (AbstractType_ConversionFunction = {}));
 //# sourceMappingURL=AbstractType_ConversionFunction.js.map