@shaclmate/compiler 3.0.4 → 4.0.1

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

@@ -0,0 +1,52 @@
+import { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectType_createFunctionDeclaration() {
+    if (!this.features.has("create")) {
+        return Maybe.empty();
+    }
+    const parametersPropertySignatures = this.properties.flatMap((property) => property.constructorParametersSignature.toList());
+    const parametersType = [];
+    if (parametersPropertySignatures.length > 0) {
+        parametersType.push(code `{ ${joinCode(parametersPropertySignatures)} }`);
+    }
+    for (const parentObjectType of this.parentObjectTypes) {
+        parametersType.push(code `Parameters<typeof ${parentObjectType.staticModuleName}.${syntheticNamePrefix}create>[0]`);
+    }
+    if (parametersType.length === 0) {
+        parametersType.push(code `object`);
+    }
+    const propertyInitializers = [];
+    const omitPropertyNames = [];
+    const propertyStatements = [];
+    for (const parentObjectType of this.parentObjectTypes) {
+        propertyInitializers.push(`...${parentObjectType.staticModuleName}.${syntheticNamePrefix}create(parameters)`);
+    }
+    const parametersHasQuestionToken = this.parentObjectTypes.length === 0 &&
+        parametersPropertySignatures.every((propertySignature) => propertySignature.toCodeString([]).indexOf("?:") !== -1);
+    const parametersVariable = code `parameters${parametersHasQuestionToken ? "?" : ""}`;
+    for (const property of this.properties) {
+        const thisPropertyStatements = property.constructorStatements({
+            variables: {
+                parameter: code `${parametersVariable}.${property.name}`,
+                parameters: parametersVariable,
+            },
+        });
+        if (thisPropertyStatements.length > 0) {
+            propertyInitializers.push(property.name);
+            propertyStatements.push(...thisPropertyStatements);
+        }
+        else {
+            omitPropertyNames.push(property.name);
+        }
+    }
+    invariant(propertyInitializers.length > 0);
+    invariant(propertyStatements.length > 0);
+    return Maybe.of(code `\
+export function ${syntheticNamePrefix}create(parameters${parametersHasQuestionToken ? "?" : ""}: ${joinCode(parametersType, { on: " & " })}): ${omitPropertyNames.length === 0 ? this.name : `Omit<${this.name}, ${omitPropertyNames.map((omitPropertyName) => `"${omitPropertyName}"`).join(" | ")}>`} {
+  ${joinCode(propertyStatements)}
+  return { ${propertyInitializers.join(", ")} };
+}`);
+}
+//# sourceMappingURL=ObjectType_createFunctionDeclaration.js.map

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

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

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

@@ -0,0 +1,51 @@
+import { Maybe } from "purify-ts";
+import { snippets } from "../snippets.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectType_equalsFunctionOrMethodDeclaration() {
+    if (!this.features.has("equals")) {
+        return Maybe.empty();
+    }
+    const chain = [];
+    let leftVariable;
+    let parameters;
+    let preamble;
+    let rightVariable;
+    switch (this.declarationType) {
+        case "class":
+            if (this.ownProperties.length === 0) {
+                // If there's a parent class and no properties in this class, can skip overriding equals
+                return Maybe.empty();
+            }
+            leftVariable = "this";
+            parameters = code `other: ${this.name}`;
+            if (this.parentObjectTypes.length > 0) {
+                chain.push(code `super.${syntheticNamePrefix}equals(other)`);
+                preamble = "override ";
+            }
+            else {
+                preamble = "";
+            }
+            rightVariable = "other";
+            break;
+        case "interface":
+            // For every parent, find the nearest equals implementation
+            for (const parentObjectType of this.parentObjectTypes) {
+                chain.push(code `${parentObjectType.staticModuleName}.${syntheticNamePrefix}equals(left, right)`);
+            }
+            leftVariable = "left";
+            parameters = code `left: ${this.name}, right: ${this.name}`;
+            preamble = "export function ";
+            rightVariable = "right";
+    }
+    for (const property of this.ownProperties) {
+        property.equalsFunction.ifJust((equalsFunction) => {
+            chain.push(code `(${equalsFunction})(${leftVariable}.${property.name}, ${rightVariable}.${property.name}).mapLeft(propertyValuesUnequal => ({ left: ${leftVariable}, right: ${rightVariable}, propertyName: "${property.name}", propertyValuesUnequal, type: "property" as const }))`);
+        });
+    }
+    return Maybe.of(code `\
+${preamble}${syntheticNamePrefix}equals(${parameters}): ${snippets.EqualsResult} {
+  return ${joinCode(chain.map((chainPart, chainPartI) => chainPartI === 0 ? chainPart : code `chain(() => ${chainPart})`), { on: "." })}
+}`);
+}
+//# sourceMappingURL=ObjectType_equalsFunctionOrMethodDeclaration.js.map

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

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

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

@@ -0,0 +1,21 @@
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectType_filterFunctionDeclaration() {
+    const statements = [];
+    for (const parentObjectType of this.parentObjectTypes) {
+        statements.push(code `if (!${parentObjectType.filterFunction}(filter, value)) { return false; }`);
+    }
+    if (this.ownProperties.length > 0) {
+        for (const ownProperty of this.ownProperties) {
+            ownProperty.filterProperty.ifJust(({ name }) => {
+                statements.push(code `if (filter.${name} !== undefined && !${ownProperty.type.filterFunction}(filter.${name}, value.${ownProperty.name})) { return false; }`);
+            });
+        }
+    }
+    statements.push(code `return true;`);
+    return code `\
+export function ${syntheticNamePrefix}filter(filter: ${this.filterType}, value: ${this.name}): boolean {
+  ${joinCode(statements)}
+}`;
+}
+//# sourceMappingURL=ObjectType_filterFunctionDeclaration.js.map

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

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

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

@@ -0,0 +1,22 @@
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectType_filterTypeDeclaration() {
+    const members = [];
+    if (this.properties.length > 0) {
+        const filterProperties = {};
+        for (const property of this.properties) {
+            property.filterProperty.ifJust(({ name, type }) => {
+                filterProperties[name] = type;
+            });
+        }
+        if (Object.entries(filterProperties).length > 0) {
+            members.push(code `{ ${joinCode(Object.entries(filterProperties).map(([name, type]) => code `readonly ${name}?: ${type}`), { on: ";" })} }`);
+        }
+    }
+    for (const parentObjectType of this.parentObjectTypes) {
+        members.push(code `${parentObjectType.staticModuleName}.${syntheticNamePrefix}Filter`);
+    }
+    return code `\
+export type ${syntheticNamePrefix}Filter = ${members.length > 0 ? joinCode(members, { on: " & " }) : "object"};`;
+}
+//# sourceMappingURL=ObjectType_filterTypeDeclaration.js.map

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

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

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

@@ -0,0 +1,13 @@
+import { Maybe } from "purify-ts";
+import { imports } from "../imports.js";
+import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectType_fromRdfTypeVariableStatement() {
+    if (!this.features.has("rdf")) {
+        return Maybe.empty();
+    }
+    return this.fromRdfType.map((fromRdfType) => code `\
+export const ${syntheticNamePrefix}fromRdfType: ${imports.NamedNode}<string> = ${rdfjsTermExpression(fromRdfType)};`);
+}
+//# sourceMappingURL=ObjectType_fromRdfTypeVariableStatement.js.map

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

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

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

@@ -0,0 +1,35 @@
+import { Maybe } from "purify-ts";
+import { imports } from "../imports.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectType_graphqlTypeVariableStatement() {
+    if (!this.features.has("graphql")) {
+        return Maybe.empty();
+    }
+    if (this.synthetic) {
+        return Maybe.empty();
+    }
+    return Maybe.of(code `\
+export const ${syntheticNamePrefix}GraphQL = new ${imports.GraphQLObjectType}<${this.name}, { objectSet: ${syntheticNamePrefix}ObjectSet }>(${{
+        description: this.comment.extract(),
+        fields: code `() => (${this.properties.reduce((fields, property) => {
+            property.graphqlField.ifJust((field) => {
+                fields[field.name] = {
+                    args: field.args
+                        .map((args) => Object.entries(args).reduce((argObjects, [argName, arg]) => {
+                        argObjects[argName] = arg;
+                        return argObjects;
+                    }, {}))
+                        .extract(),
+                    description: field.description.extract(),
+                    name: field.name,
+                    resolve: field.resolve,
+                    type: field.type,
+                };
+            });
+            return fields;
+        }, {})})`,
+        name: this.name,
+    }});`);
+}
+//# sourceMappingURL=ObjectType_graphqlTypeVariableStatement.js.map

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

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

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

@@ -0,0 +1,73 @@
+import { snippets } from "../snippets.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+const hasherVariable = code `_hasher`;
+export function ObjectType_hashFunctionOrMethodDeclarations() {
+    if (!this.features.has("hash")) {
+        return [];
+    }
+    const hashOwnShaclPropertiesStatements = this.ownShaclProperties.flatMap((property) => property.hashStatements({
+        depth: 0,
+        variables: {
+            hasher: hasherVariable,
+            value: code `${this.thisVariable}.${property.name}`,
+        },
+    }));
+    if (this.declarationType === "class" &&
+        this.parentObjectTypes.length > 0 &&
+        hashOwnShaclPropertiesStatements.length === 0) {
+        // If there's a parent class and no hash statements in this class, can skip overriding hash
+        return [];
+    }
+    const hashShaclPropertiesStatements = [];
+    const hashStatements = [];
+    const parameters = []; // Same between the two functions
+    let hashPreamble = "";
+    let hashShaclPropertiesPreamble = "";
+    switch (this.declarationType) {
+        case "class": {
+            if (this.parentObjectTypes.length > 0) {
+                hashShaclPropertiesStatements.push(code `super.${syntheticNamePrefix}hashShaclProperties(${hasherVariable});`);
+                hashShaclPropertiesPreamble = "override ";
+                hashPreamble = "override ";
+            }
+            hashShaclPropertiesPreamble = `protected ${hashShaclPropertiesPreamble}`;
+            hashStatements.push(code `this.${syntheticNamePrefix}hashShaclProperties(${hasherVariable});`);
+            break;
+        }
+        case "interface": {
+            for (const parentObjectType of this.parentObjectTypes) {
+                hashShaclPropertiesStatements.push(code `${parentObjectType.staticModuleName}.${syntheticNamePrefix}hashShaclProperties(${this.thisVariable}, ${hasherVariable});`);
+            }
+            parameters.push(code `${this.thisVariable}: ${this.name}`);
+            hashPreamble = hashShaclPropertiesPreamble = "export function ";
+            hashStatements.push(code `${this.staticModuleName}.${syntheticNamePrefix}hashShaclProperties(${this.thisVariable}, ${hasherVariable});`);
+            break;
+        }
+    }
+    parameters.push(code `${hasherVariable}: HasherT`);
+    const parametersCode = joinCode(parameters, { on: "," });
+    hashShaclPropertiesStatements.push(...hashOwnShaclPropertiesStatements);
+    hashShaclPropertiesStatements.push(code `return ${hasherVariable};`);
+    hashStatements.push(...this.ownProperties
+        .filter((property) => property.kind !== "ShaclProperty")
+        .flatMap((property) => property.hashStatements({
+        depth: 0,
+        variables: {
+            hasher: hasherVariable,
+            value: code `${this.thisVariable}.${property.name}`,
+        },
+    })));
+    hashStatements.push(code `return ${hasherVariable};`);
+    return [
+        code `\
+${hashPreamble}${syntheticNamePrefix}hash<HasherT extends ${snippets.Hasher}>(${parametersCode}): HasherT {
+  ${joinCode(hashStatements)}
+}`,
+        code `\
+${hashShaclPropertiesPreamble}${syntheticNamePrefix}hashShaclProperties<HasherT extends ${snippets.Hasher}>(${parametersCode}): HasherT {
+  ${joinCode(hashShaclPropertiesStatements)}
+}`,
+    ];
+}
+//# sourceMappingURL=ObjectType_hashFunctionOrMethodDeclarations.js.map

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

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

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

@@ -0,0 +1,16 @@
+import { code, joinCode } from "../ts-poet-wrapper.js";
+import { tsComment } from "../tsComment.js";
+export function ObjectType_interfaceDeclaration() {
+    return code `\
+${this.comment
+        .alt(this.label)
+        .map(tsComment)
+        .orDefault("")}export interface ${this.name}${this.parentObjectTypes.length > 0
+        ? ` extends ${this.parentObjectTypes
+            .map((parentObjectType) => parentObjectType.name)
+            .join(", ")}`
+        : ""} {
+  ${joinCode(this.properties.flatMap((property) => property.declaration.toList()))}
+}`;
+}
+//# sourceMappingURL=ObjectType_interfaceDeclaration.js.map

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

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

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

@@ -0,0 +1,14 @@
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectType_isTypeFunctionDeclaration() {
+    return code `\
+export function is${this.name}(object: ${syntheticNamePrefix}Object): object is ${this.name} {
+  switch (object.${this._discriminantProperty.name}) {
+    ${this._discriminantProperty.descendantValues
+        .concat(this._discriminantProperty.ownValues)
+        .map((value) => `case "${value}":`)
+        .join("\n")} return true; default: return false;
+  }
+}`;
+}
+//# sourceMappingURL=ObjectType_isTypeFunctionDeclaration.js.map

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

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

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

@@ -0,0 +1,122 @@
+import { Maybe } from "purify-ts";
+import { imports } from "../imports.js";
+import { snippets } from "../snippets.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+import { ObjectType_toJsonFunctionOrMethodDeclaration } from "./ObjectType_toJsonFunctionOrMethodDeclaration.js";
+function ObjectType_fromJsonFunctionDeclarations() {
+    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;
+}
+function ObjectType_jsonSchemaFunctionDeclaration() {
+    return code `\
+export function ${syntheticNamePrefix}jsonSchema() {
+  return ${imports.z}.toJSONSchema(${syntheticNamePrefix}jsonZodSchema());
+}`;
+}
+function ObjectType_jsonUiSchemaFunctionDeclaration() {
+    const variables = { scopePrefix: code `scopePrefix` };
+    const elements = this.parentObjectTypes
+        .map((parentObjectType) => code `${parentObjectType.staticModuleName}.${syntheticNamePrefix}jsonUiSchema({ scopePrefix })`)
+        .concat(this.ownProperties.flatMap((property) => property.jsonUiSchemaElement({ variables }).toList()));
+    return code `\
+export function ${syntheticNamePrefix}jsonUiSchema(parameters?: { scopePrefix?: string }): any {
+  const scopePrefix = parameters?.scopePrefix ?? "#";
+  return { "elements": [ ${joinCode(elements, { on: "," })} ], label: "${this.label.orDefault(this.name)}", type: "Group" };
+}`;
+}
+function ObjectType_jsonZodSchemaFunctionDeclaration() {
+    const mergeZodObjectSchemas = [];
+    for (const parentObjectType of this.parentObjectTypes) {
+        mergeZodObjectSchemas.push(parentObjectType.jsonZodSchema({ context: "type" }));
+    }
+    if (this.properties.length > 0) {
+        mergeZodObjectSchemas.push(code `${imports.z}.object({ ${joinCode(this.properties
+            .flatMap((property) => property.jsonZodSchema.toList())
+            .map(({ key, schema }) => code `"${key}": ${schema}`), { on: "," })} })`);
+    }
+    return code `\
+export function ${syntheticNamePrefix}jsonZodSchema() {
+  return ${mergeZodObjectSchemas.length > 0
+        ? mergeZodObjectSchemas.reduce((merged, zodObjectSchema) => {
+            if (merged === null) {
+                return zodObjectSchema;
+            }
+            return code `${merged}.merge(${zodObjectSchema})`;
+        }, null)
+        : `${imports.z}.object()`} satisfies ${imports.z}.ZodType<${syntheticNamePrefix}Json>;
+}`;
+}
+function ObjectType_toJsonFunctionDeclaration() {
+    if (this.declarationType !== "interface") {
+        return Maybe.empty();
+    }
+    return ObjectType_toJsonFunctionOrMethodDeclaration.bind(this)();
+}
+export function ObjectType_jsonFunctionDeclarations() {
+    if (!this.features.has("json")) {
+        return [];
+    }
+    return [
+        ...ObjectType_fromJsonFunctionDeclarations.bind(this)(),
+        ObjectType_jsonSchemaFunctionDeclaration.bind(this)(),
+        ObjectType_jsonUiSchemaFunctionDeclaration.bind(this)(),
+        ...ObjectType_toJsonFunctionDeclaration.bind(this)().toList(),
+        ObjectType_jsonZodSchemaFunctionDeclaration.bind(this)(),
+    ];
+}
+const variables = {
+    jsonObject: code `${syntheticNamePrefix}jsonObject`,
+};
+//# sourceMappingURL=ObjectType_jsonFunctionDeclarations.js.map

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

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

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

@@ -0,0 +1,17 @@
+import { Maybe } from "purify-ts";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectType_jsonTypeAliasDeclaration() {
+    if (!this.features.has("json")) {
+        return Maybe.empty();
+    }
+    const members = [];
+    if (this.ownProperties.length > 0) {
+        members.push(code `{ ${joinCode(this.ownProperties.flatMap((property) => property.jsonSignature.toList()), { on: ";" })} }`);
+    }
+    for (const parentObjectType of this.parentObjectTypes) {
+        members.push(code `${parentObjectType.jsonType().name}`);
+    }
+    return Maybe.of(code `export type ${syntheticNamePrefix}Json = ${members.length > 0 ? joinCode(members, { on: " & " }) : "object"};`);
+}
+//# sourceMappingURL=ObjectType_jsonTypeAliasDeclaration.js.map

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

@@ -0,0 +1,9 @@
+export declare function ObjectType_objectSetMethodNames(this: {
+    readonly name: string;
+}): {
+    object: string;
+    objectCount: string;
+    objectIdentifiers: string;
+    objects: string;
+};
+//# sourceMappingURL=ObjectType_objectSetMethodNames.d.ts.map

package/dist/generators/ts/_ObjectType/{objectSetMethodNames.js → ObjectType_objectSetMethodNames.js}

@@ -1,6 +1,6 @@
 import { camelCase, trainCase } from "change-case";
 import plur from "plur";
-export function objectSetMethodNames() {
+export function ObjectType_objectSetMethodNames() {
     const prefixSingular = camelCase(this.name);
     const thisNameParts = trainCase(this.name).split("-");
     let prefixPlural = camelCase(`${thisNameParts.slice(0, thisNameParts.length - 1).join("")}${plur(thisNameParts[thisNameParts.length - 1])}`);
@@ -10,9 +10,9 @@ export function objectSetMethodNames() {
     }
     return {
         object: prefixSingular,
+        objectCount: `${prefixSingular}Count`,
         objectIdentifiers: `${prefixSingular}Identifiers`,
         objects: prefixPlural,
-        objectsCount: `${prefixPlural}Count`,
     };
 }
-//# sourceMappingURL=objectSetMethodNames.js.map
+//# sourceMappingURL=ObjectType_objectSetMethodNames.js.map

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

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