@shaclmate/compiler 4.0.8 → 4.0.9

package/dist/generators/ts/UnionType.js

@@ -1,527 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { Maybe, NonEmptyList } from "purify-ts";
-import { invariant } from "ts-invariant";
-import { Memoize } from "typescript-memoize";
-import { AbstractType } from "./AbstractType.js";
-import { codeEquals } from "./codeEquals.js";
-import { imports } from "./imports.js";
-import { snippets } from "./snippets.js";
-import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
-class MemberType {
-    delegate;
-    delegateIndex;
-    discriminant;
-    universe;
-    constructor({ delegate, delegateIndex, discriminant, universe, }) {
-        this.delegate = delegate;
-        this.delegateIndex = delegateIndex;
-        this.discriminant = discriminant;
-        this.universe = universe;
-    }
-    get discriminantValues() {
-        switch (this.discriminant.kind) {
-            case "envelope":
-                return [this.discriminant.ownValues[this.delegateIndex]];
-            case "inline": {
-                // A member type's combined discriminant property values are its "own" values plus any descendant values that are
-                // not the "own" values of some other member type.
-                // So if you have type A, type B, and B inherits A, then
-                // A has
-                //   own discriminant property values: ["A"]
-                //   descendant discriminant property values: ["B"]
-                // and B has
-                //  own discriminant property values: ["B"]
-                //  descendant discriminant property values ["B"]
-                // In this case A shouldn't have "B" as a combined discriminant property value since it's "claimed" by B.
-                const memberOwnDiscriminantPropertyValues = new Set();
-                for (const memberType of this.universe) {
-                    for (const ownDiscriminantPropertyValue of memberType.discriminantProperty.unsafeCoerce()
-                        .ownValues) {
-                        memberOwnDiscriminantPropertyValues.add(ownDiscriminantPropertyValue);
-                    }
-                }
-                return this.delegate.discriminantProperty
-                    .unsafeCoerce()
-                    .ownValues.concat(this.delegate.discriminantProperty
-                    .unsafeCoerce()
-                    .descendantValues.filter((value) => !memberOwnDiscriminantPropertyValues.has(value)));
-            }
-            case "typeof":
-                return this.delegate.typeofs;
-            default:
-                throw this.discriminant;
-        }
-    }
-    get equalsFunction() {
-        return this.delegate.equalsFunction;
-    }
-    get filterFunction() {
-        return this.delegate.filterFunction;
-    }
-    get filterType() {
-        return this.delegate.filterType;
-    }
-    get mutable() {
-        return this.delegate.mutable;
-    }
-    get name() {
-        return this.delegate.name;
-    }
-    get schema() {
-        return this.delegate.schema;
-    }
-    get schemaType() {
-        return this.delegate.schemaType;
-    }
-    get sparqlConstructTriplesFunction() {
-        return this.delegate.sparqlConstructTriplesFunction;
-    }
-    get sparqlWherePatternsFunction() {
-        return this.delegate.sparqlWherePatternsFunction;
-    }
-    get typeofs() {
-        return this.delegate.typeofs;
-    }
-    fromJsonExpression(parameters) {
-        return this.delegate.fromJsonExpression(parameters);
-    }
-    fromRdfExpression(parameters) {
-        return this.delegate.fromRdfExpression(parameters);
-    }
-    hashStatements(parameters) {
-        return this.delegate.hashStatements(parameters);
-    }
-    jsonType(parameters) {
-        return this.delegate.jsonType(parameters);
-    }
-    jsonZodSchema(parameters) {
-        return this.delegate.jsonZodSchema(parameters);
-    }
-    payload(instance) {
-        switch (this.discriminant.kind) {
-            case "envelope":
-                return code `${instance}.value`;
-            case "inline":
-            case "typeof":
-                return instance;
-        }
-    }
-    toJsonExpression(parameters) {
-        return this.delegate.toJsonExpression(parameters);
-    }
-    toRdfExpression(parameters) {
-        return this.delegate.toRdfExpression(parameters);
-    }
-}
-__decorate([
-    Memoize()
-], MemberType.prototype, "discriminantValues", null);
-export class UnionType extends AbstractType {
-    discriminant;
-    memberTypes;
-    #name;
-    graphqlArgs = Maybe.empty();
-    kind = "UnionType";
-    constructor({ memberDiscriminantValues, memberTypes, ...superParameters }) {
-        super(superParameters);
-        invariant(memberTypes.length >= 2);
-        invariant(memberDiscriminantValues.length === 0 ||
-            memberDiscriminantValues.length === memberTypes.length);
-        let discriminant;
-        if (memberDiscriminantValues.length === 0) {
-            // Infer the discriminant kind
-            const inlineDiscriminantProperty_ = inlineDiscriminantProperty(memberTypes);
-            if (inlineDiscriminantProperty_) {
-                discriminant = {
-                    ...inlineDiscriminantProperty_,
-                    kind: "inline",
-                };
-            }
-            else {
-                const memberTypeofs = new Set();
-                for (const memberType of memberTypes) {
-                    for (const typeof_ of memberType.typeofs) {
-                        memberTypeofs.add(typeof_);
-                    }
-                }
-                if (memberTypeofs.size === memberTypes.length) {
-                    discriminant = {
-                        kind: "typeof",
-                    };
-                }
-            }
-        }
-        if (!discriminant) {
-            discriminant = {
-                descendantValues: [],
-                kind: "envelope",
-                name: "type",
-                ownValues: memberDiscriminantValues.length > 0
-                    ? memberDiscriminantValues
-                    : memberTypes.map((memberType, memberTypeIndex) => `${memberTypeIndex}-${memberType.name}`),
-            };
-        }
-        this.discriminant = discriminant;
-        this.memberTypes = memberTypes.map((memberType, memberTypeIndex) => new MemberType({
-            delegate: memberType,
-            delegateIndex: memberTypeIndex,
-            discriminant: this.discriminant,
-            universe: memberTypes,
-        }));
-    }
-    get conversions() {
-        switch (this.discriminant.kind) {
-            case "envelope":
-            case "inline":
-                return [
-                    {
-                        conversionExpression: (value) => value,
-                        sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
-                        sourceTypeName: this.name,
-                        sourceTypeof: "object",
-                    },
-                ];
-            case "typeof":
-                return this.memberTypes.map((memberType) => ({
-                    conversionExpression: (value) => value,
-                    sourceTypeCheckExpression: (value) => code `typeof ${value} === "${memberType.discriminantValues[0]}"`,
-                    sourceTypeName: memberType.name,
-                    sourceTypeof: memberType.discriminantValues[0],
-                }));
-            default:
-                throw this.discriminant;
-        }
-    }
-    get discriminantProperty() {
-        switch (this.discriminant.kind) {
-            case "envelope":
-            case "inline":
-                return Maybe.of(this.discriminant);
-            case "typeof":
-                return Maybe.empty();
-            default:
-                throw this.discriminant;
-        }
-    }
-    get equalsFunction() {
-        return code `\
-((left: ${this.name}, right: ${this.name}) => {
-${joinCode(this.memberTypes.flatMap((memberType) => memberType.discriminantValues.map((value) => code `if (${this.discriminantVariable(code `left`)} === "${value}" && ${this.discriminantVariable(code `right`)} === "${value}") {
-  return ${memberType.equalsFunction}(${memberType.payload(code `left`)}, ${memberType.payload(code `right`)});
-}`)))}
-
-  return ${imports.Left}({ left, right, propertyName: "type", propertyValuesUnequal: { left: typeof left, right: typeof right, type: "boolean" as const }, type: "property" as const });
-})`;
-    }
-    get filterFunction() {
-        return code `\
-((filter: ${this.filterType}, value: ${this.name}) => {
-${joinCode(this.memberTypes.map((memberType) => code `\
-if (filter.on?.["${memberType.discriminantValues[0]}"] !== undefined) {
-  switch (${this.discriminantVariable(code `value`)}) {
-${memberType.discriminantValues.map((discriminantValue) => `case "${discriminantValue}":`)}
-    if (!${memberType.filterFunction}(filter.on["${memberType.discriminantValues[0]}"], ${memberType.payload(code `value`)})) {
-      return false;
-    }
-    break;
-  }
-}`))}
-
-  return true;
-})`;
-    }
-    get filterType() {
-        return code `{ readonly on?: { ${joinCode(this.memberTypes.map((memberType) => code `readonly "${memberType.discriminantValues[0]}"?: ${memberType.filterType}`), { on: ";" })} } }`;
-    }
-    get graphqlType() {
-        throw new Error("GraphQL doesn't support scalar unions");
-    }
-    get mutable() {
-        return this.memberTypes.some((memberType) => memberType.mutable);
-    }
-    get name() {
-        if (this.#name === undefined) {
-            switch (this.discriminant.kind) {
-                case "envelope":
-                    this.#name = code `(${joinCode(this.memberTypes.map((memberType) => code `{ ${this.discriminant.name}: ${literalOf(memberType.discriminantValues[0])}, value: ${memberType.name} }`), { on: "|" })})`;
-                    break;
-                case "inline":
-                    // If every type shares a discriminant (e.g., RDF/JS "termType" or generated ObjectType "type"),
-                    // just join their names with "|"
-                    this.#name = code `(${joinCode(this.memberTypes.map((memberType) => code `${memberType.name}`), { on: "|" })})`;
-                    break;
-                case "typeof":
-                    // The memberType.name may include literal values, but they should still be unambiguous with other member types since the typeofs
-                    // of the different member types are known to be different.
-                    this.#name = code `(${joinCode(this.memberTypes.map((memberType) => code `${memberType.name}`), { on: "|" })})`;
-                    break;
-            }
-        }
-        return this.#name;
-    }
-    get schema() {
-        return code `${{
-            // discriminant: {
-            //   kind: `${JSON.stringify(this.discriminant.kind)} as const`,
-            // },
-            kind: code `${literalOf("Union")} as const`,
-            members: code `{ ${joinCode(this.memberTypes.map((memberType) => code `"${memberType.discriminantValues[0]}": ${{
-                discriminantValues: memberType.discriminantValues,
-                type: memberType.schema,
-            }}`), { on: "," })} }`,
-        }}`;
-    }
-    get schemaType() {
-        return code `${{
-            // discriminant: {
-            //   kind: '"envelope" | "inline" | "typeof"',
-            // },
-            kind: literalOf("Union"),
-            members: code `{ ${joinCode(this.memberTypes.map((memberType) => code `readonly "${memberType.discriminantValues[0]}": ${{
-                discriminantValues: code `readonly string[]`,
-                type: memberType.schemaType,
-            }}`), { on: ";" })} }`,
-        }}`;
-    }
-    get sparqlConstructTriplesFunction() {
-        return code `\
-(({ ignoreRdfType, filter, schema, ...otherParameters }: ${snippets.SparqlConstructTriplesFunctionParameters}<${this.filterType}, ${this.schemaType}>) => {
-  let triples: ${imports.sparqljs}.Triple[] = [];
-
-  ${joinCode(this.memberTypes.map((memberType) => code `\
-triples = triples.concat(${memberType.sparqlConstructTriplesFunction}({ ...otherParameters, filter: filter?.on?.["${memberType.discriminantValues[0]}"], ignoreRdfType: false, schema: schema.members["${memberType.discriminantValues[0]}"].type }));`))}
-  
-  return triples;
-})`;
-    }
-    get sparqlWherePatternsFunction() {
-        return code `\
-(({ filter, schema, ...otherParameters }: ${snippets.SparqlWherePatternsFunctionParameters}<${this.filterType}, ${this.schemaType}>) => {
-  const unionPatterns: ${imports.sparqljs}.GroupPattern[] = [];
-
-  ${joinCode(this.memberTypes.map((memberType) => code `\
-unionPatterns.push({ patterns: ${memberType.sparqlWherePatternsFunction}({ ...otherParameters, filter: filter?.on?.["${memberType.discriminantValues[0]}"], ignoreRdfType: false, schema: schema.members["${memberType.discriminantValues[0]}"].type }).concat(), type: "group" });`))}
-  
-  return [{ patterns: unionPatterns, type: "union" }];
-})`;
-    }
-    get typeofs() {
-        return NonEmptyList.fromArray(this.memberTypes.flatMap((memberType) => memberType.typeofs)).unsafeCoerce();
-    }
-    fromJsonExpression({ variables, }) {
-        return this.ternaryExpression({
-            memberTypeExpression: (memberType) => {
-                let typeExpression = memberType.fromJsonExpression({
-                    variables: {
-                        value: memberType.payload(variables.value),
-                    },
-                });
-                if (this.discriminant.kind === "envelope") {
-                    typeExpression = code `{ ${this.discriminant.name}: "${memberType.discriminantValues[0]}" as const, value: ${typeExpression} }`;
-                }
-                return typeExpression;
-            },
-            variables,
-        });
-    }
-    fromRdfExpression({ variables, }) {
-        return code `${variables.resourceValues}.chain(values => values.chainMap(value => {
-      const valueAsValues = ${imports.Right}(value.toValues());
-      return ${this.memberTypes.reduce((expression, memberType) => {
-            let typeExpression = memberType.fromRdfExpression({
-                variables: {
-                    ...variables,
-                    ignoreRdfType: false,
-                    resourceValues: code `valueAsValues`,
-                },
-            });
-            if (this.discriminant.kind === "envelope") {
-                typeExpression = code `${typeExpression}.map(values => values.map(value => ({ ${this.discriminant.name}: "${memberType.discriminantValues[0]}" as const, value }) as (${this.name})))`;
-            }
-            typeExpression = code `(${typeExpression} as ${imports.Either}<Error, ${imports.Resource}.Values<${this.name}>>)`;
-            return expression !== null
-                ? code `${expression}.altLazy(() => ${typeExpression})`
-                : typeExpression;
-        }, null)}.chain(values => values.head());
-      }))`;
-    }
-    graphqlResolveExpression(_parameters) {
-        throw new Error("not implemented");
-    }
-    hashStatements({ depth, variables, }) {
-        const caseBlocks = [];
-        for (const memberType of this.memberTypes) {
-            caseBlocks.push(code `${memberType.discriminantValues.map((discriminantPropertyValue) => `case "${discriminantPropertyValue}":`).join()} { ${joinCode(memberType
-                .hashStatements({
-                depth: depth + 1,
-                variables: {
-                    hasher: variables.hasher,
-                    value: memberType.payload(variables.value),
-                },
-            })
-                .concat())}; break; }`);
-        }
-        caseBlocks.push(code `default: ${variables.value} satisfies never; throw new Error("unrecognized type");`);
-        return [
-            code `switch (${this.discriminantVariable(variables.value)}) { ${joinCode(caseBlocks)} }`,
-        ];
-    }
-    jsonType() {
-        switch (this.discriminant.kind) {
-            case "envelope":
-                return new AbstractType.JsonType(code `(${joinCode(this.memberTypes.map((memberType) => code `{ ${this.discriminant.name}: "${memberType.discriminantValues[0]}", value: ${memberType.jsonType().name} }`), { on: "|" })})`);
-            case "inline":
-            case "typeof":
-                return new AbstractType.JsonType(joinCode(this.memberTypes.map((memberType) => code `${memberType.jsonType({
-                    includeDiscriminantProperty: this.discriminant.kind === "inline",
-                }).name}`), { on: "|" }));
-            default:
-                throw this.discriminant;
-        }
-    }
-    jsonUiSchemaElement() {
-        return Maybe.empty();
-    }
-    jsonZodSchema(_parameters) {
-        switch (this.discriminant.kind) {
-            case "envelope":
-                return code `${imports.z}.discriminatedUnion("${this.discriminant.name}", [${joinCode(this.memberTypes.map((memberType) => code `${imports.z}.object({ ${this.discriminant.name}: ${imports.z}.literal("${memberType.discriminantValues[0]}"), value: ${memberType.jsonZodSchema({ context: "type" })} })`), { on: "," })}])`;
-            case "inline":
-                return code `${imports.z}.discriminatedUnion("${this.discriminant.name}", [${joinCode(this.memberTypes.map((memberType) => memberType.jsonZodSchema({
-                    includeDiscriminantProperty: true,
-                    context: "type",
-                })), { on: "," })}])`;
-            case "typeof":
-                return code `${imports.z}.union([${joinCode(this.memberTypes.map((memberType) => memberType.jsonZodSchema({ context: "type" })), { on: "," })}])`;
-            default:
-                throw this.discriminant;
-        }
-    }
-    toJsonExpression({ variables, }) {
-        switch (this.discriminant.kind) {
-            case "envelope":
-                return this.ternaryExpression({
-                    memberTypeExpression: (memberType) => code `{ ${this.discriminant.name}: "${memberType.discriminantValues[0]}" as const, value: ${memberType.toJsonExpression({
-                        variables: {
-                            ...variables,
-                            value: memberType.payload(variables.value),
-                        },
-                    })} }`,
-                    variables,
-                });
-            case "inline":
-            case "typeof":
-                return this.ternaryExpression({
-                    memberTypeExpression: (memberType) => memberType.toJsonExpression({
-                        includeDiscriminantProperty: this.discriminant.kind === "inline",
-                        variables: {
-                            ...variables,
-                            value: memberType.payload(variables.value),
-                        },
-                    }),
-                    variables,
-                });
-        }
-    }
-    toRdfExpression({ variables, }) {
-        return this.ternaryExpression({
-            memberTypeExpression: (memberType) => code `(${memberType.toRdfExpression({
-                variables: {
-                    ...variables,
-                    value: memberType.payload(variables.value),
-                },
-            })} as (bigint | boolean | number | string | ${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode})[])`,
-            variables,
-        });
-    }
-    discriminantVariable(variableValue) {
-        switch (this.discriminant.kind) {
-            case "envelope":
-            case "inline":
-                return code `${variableValue}.${this.discriminant.name}`;
-            case "typeof":
-                return code `(typeof ${variableValue})`;
-        }
-    }
-    ternaryExpression({ memberTypeExpression, variables, }) {
-        return this.memberTypes.reduce((expression, memberType) => {
-            if (expression === null) {
-                return memberTypeExpression(memberType);
-            }
-            const memberTypeExpression_ = memberTypeExpression(memberType);
-            if (codeEquals(memberTypeExpression_, expression)) {
-                return expression;
-            }
-            return code `(${joinCode(memberType.discriminantValues.map((value) => code `${this.discriminantVariable(variables.value)} === "${value}"`), { on: "||" })}) ? ${memberTypeExpression_} : ${expression}`;
-        }, null);
-    }
-}
-__decorate([
-    Memoize()
-], UnionType.prototype, "conversions", null);
-__decorate([
-    Memoize()
-], UnionType.prototype, "discriminantProperty", null);
-__decorate([
-    Memoize()
-], UnionType.prototype, "equalsFunction", null);
-__decorate([
-    Memoize()
-], UnionType.prototype, "filterFunction", null);
-__decorate([
-    Memoize()
-], UnionType.prototype, "filterType", null);
-__decorate([
-    Memoize()
-], UnionType.prototype, "mutable", null);
-__decorate([
-    Memoize()
-], UnionType.prototype, "name", null);
-__decorate([
-    Memoize()
-], UnionType.prototype, "schema", null);
-__decorate([
-    Memoize()
-], UnionType.prototype, "sparqlConstructTriplesFunction", null);
-__decorate([
-    Memoize()
-], UnionType.prototype, "sparqlWherePatternsFunction", null);
-__decorate([
-    Memoize()
-], UnionType.prototype, "typeofs", null);
-__decorate([
-    Memoize()
-], UnionType.prototype, "jsonType", null);
-function inlineDiscriminantProperty(memberTypes) {
-    let inlineDiscriminantProperty;
-    for (const memberType of memberTypes) {
-        const memberTypeDiscriminantProperty = memberType.discriminantProperty.extract();
-        if (!memberTypeDiscriminantProperty) {
-            inlineDiscriminantProperty = undefined;
-            break;
-        }
-        if (!inlineDiscriminantProperty) {
-            inlineDiscriminantProperty = {
-                name: memberTypeDiscriminantProperty.name,
-                ownValues: memberTypeDiscriminantProperty.ownValues.concat(),
-                descendantValues: memberTypeDiscriminantProperty.descendantValues.concat(),
-            };
-        }
-        else if (memberTypeDiscriminantProperty.name === inlineDiscriminantProperty.name) {
-            inlineDiscriminantProperty.descendantValues =
-                inlineDiscriminantProperty.descendantValues.concat(memberTypeDiscriminantProperty.descendantValues);
-            inlineDiscriminantProperty.ownValues =
-                inlineDiscriminantProperty.ownValues.concat(memberTypeDiscriminantProperty.ownValues);
-        }
-        else {
-            return undefined;
-        }
-    }
-    return inlineDiscriminantProperty;
-}
-//# sourceMappingURL=UnionType.js.map

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

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

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

@@ -1,66 +0,0 @@
-import { imports } from "../imports.js";
-import { snippets } from "../snippets.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
-import { code, joinCode } from "../ts-poet-wrapper.js";
-const variables = {
-    jsonObject: code `${syntheticNamePrefix}jsonObject`,
-};
-export function ObjectType_fromJsonFunctionDeclarations() {
-    if (!this.features.has("json")) {
-        return [];
-    }
-    const initializers = [];
-    const propertiesFromJsonReturnType = [];
-    const propertiesFromJsonStatements = [];
-    const propertyReturnTypeSignatures = [];
-    propertiesFromJsonStatements.push(code `const ${syntheticNamePrefix}jsonSafeParseResult = ${syntheticNamePrefix}jsonZodSchema().safeParse(_json);`, code `if (!${syntheticNamePrefix}jsonSafeParseResult.success) { return ${imports.Left}(${syntheticNamePrefix}jsonSafeParseResult.error); }`, code `const ${variables.jsonObject} = ${syntheticNamePrefix}jsonSafeParseResult.data;`);
-    const chains = [];
-    this.parentObjectTypes.forEach((parentObjectType, parentObjectTypeI) => {
-        chains.push({
-            expression: code `${parentObjectType.staticModuleName}.${syntheticNamePrefix}propertiesFromJson(${variables.jsonObject})`,
-            variable: `${syntheticNamePrefix}super${parentObjectTypeI}`,
-        });
-        initializers.push(`...${syntheticNamePrefix}super${parentObjectTypeI}`);
-        propertiesFromJsonReturnType.push(code `${snippets.UnwrapR}<ReturnType<typeof ${parentObjectType.staticModuleName}.${syntheticNamePrefix}propertiesFromJson>>`);
-    });
-    for (const property of this.properties) {
-        const propertyFromJsonStatements = property.fromJsonStatements({
-            variables,
-        });
-        if (propertyFromJsonStatements.length > 0) {
-            propertiesFromJsonStatements.push(...propertyFromJsonStatements);
-            initializers.push(property.name);
-            propertyReturnTypeSignatures.push(code `${property.name}: ${property.type.name};`);
-        }
-    }
-    const resultExpression = `{ ${initializers.join(", ")} }`;
-    if (chains.length === 0) {
-        propertiesFromJsonStatements.push(code `return ${imports.Right}(${resultExpression})`);
-    }
-    else {
-        propertiesFromJsonStatements.push(code `return ${chains
-            .reverse()
-            .reduce((acc, { expression, variable }, chainI) => code `(${expression}).${chainI === 0 ? "map" : "chain"}(${variable} => ${acc})`, code `(${resultExpression})`)}`);
-    }
-    if (propertyReturnTypeSignatures.length > 0) {
-        propertiesFromJsonReturnType.splice(0, 0, code `{ ${joinCode(propertyReturnTypeSignatures, { on: " " })} }`);
-    }
-    const functionDeclarations = [];
-    functionDeclarations.push(code `\
-export function ${syntheticNamePrefix}propertiesFromJson(_json: unknown): ${imports.Either}<${imports.z}.ZodError, ${joinCode(propertiesFromJsonReturnType, { on: " & " })}> {
-${joinCode(propertiesFromJsonStatements)}
-}`);
-    if (this.abstract) {
-        return functionDeclarations;
-    }
-    let propertiesFromJsonExpression = code `${syntheticNamePrefix}propertiesFromJson(json)`;
-    if (this.declarationType === "class") {
-        propertiesFromJsonExpression = code `${propertiesFromJsonExpression}.map(properties => new ${this.name}(properties))`;
-    }
-    functionDeclarations.push(code `\
-export function ${syntheticNamePrefix}fromJson(json: unknown): ${imports.Either}<${imports.z}.ZodError, ${this.name}> {
-  return ${propertiesFromJsonExpression};
-}`);
-    return functionDeclarations;
-}
-//# sourceMappingURL=ObjectType_fromJsonFunctionDeclarations.js.map

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

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

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

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

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

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

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

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

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

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

package/dist/generators/ts/_ObjectUnionType/MemberType.d.ts

@@ -1,34 +0,0 @@
-import type { AbstractDeclaredType } from "../AbstractDeclaredType.js";
-import type { ObjectType } from "../ObjectType.js";
-export declare class MemberType {
-    private readonly delegate;
-    private readonly universe;
-    constructor({ delegate, universe, }: {
-        delegate: ObjectType;
-        universe: readonly ObjectType[];
-    });
-    get _discriminantProperty(): import("../AbstractType.js").AbstractType.DiscriminantProperty;
-    get abstract(): boolean;
-    get ancestorObjectTypes(): readonly ObjectType[];
-    get declarationType(): import("../../../enums/TsObjectDeclarationType.js").TsObjectDeclarationType;
-    get descendantFromRdfTypeVariables(): readonly import("ts-poet").Code[];
-    get discriminantPropertyValues(): readonly string[];
-    get features(): ReadonlySet<"create" | "equals" | "graphql" | "hash" | "json" | "rdf" | "sparql">;
-    get filterFunction(): import("ts-poet").Code;
-    get filterType(): import("ts-poet").Code;
-    get fromRdfType(): import("purify-ts").Maybe<import("@rdfjs/types").NamedNode<string>>;
-    get fromRdfTypeVariable(): import("purify-ts").Maybe<import("ts-poet").Code>;
-    get graphqlType(): import("../AbstractType.js").AbstractType.GraphqlType;
-    get identifierTypeAlias(): import("ts-poet").Code;
-    get mutable(): boolean;
-    get name(): string;
-    get ownProperties(): readonly import("../_ObjectType/Property.js").Property[];
-    get properties(): readonly import("../_ObjectType/Property.js").Property[];
-    get staticModuleName(): string;
-    get toRdfjsResourceType(): import("ts-poet").Code;
-    jsonType(): import("../AbstractType.js").AbstractType.JsonType;
-    jsonZodSchema(parameters: Parameters<AbstractDeclaredType["jsonZodSchema"]>[0]): import("ts-poet").Code;
-    newExpression(parameters: Parameters<ObjectType["newExpression"]>[0]): import("ts-poet").Code;
-    toObjectType(): ObjectType;
-}
-//# sourceMappingURL=MemberType.d.ts.map