@shaclmate/compiler 4.0.94 → 4.0.95

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

@@ -1,5 +0,0 @@
-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/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_fromJsonFunctionExpression.js

@@ -1,14 +0,0 @@
-import { code, joinCode } from "../ts-poet-wrapper.js";
-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({
-        variables: {
-            value: code `(${unwrap(code `value`)} as ${jsonType})`,
-        },
-    })}.map(value => (${wrap(code `value`)})); }`))}
-
-  throw new Error("unable to deserialize JSON");
-})`;
-}
-//# sourceMappingURL=AbstractDiscriminatedUnionType_fromJsonFunctionExpression.js.map

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

@@ -1,5 +0,0 @@
-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/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_jsonSchemaExpression.js

@@ -1,32 +0,0 @@
-import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
-export function AbstractDiscriminatedUnionType_jsonSchemaExpression() {
-    const discriminant = this.discriminant; // To get type narrowing to work
-    switch (discriminant.kind) {
-        case "Extrinsic":
-            return code `${this.reusables.imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `${this.reusables.imports.z}.object({ ${discriminant.name}: ${this.reusables.imports.z}.literal(${literalOf(primaryDiscriminantValue)}), value: ${type.jsonSchema({ context: "type" })} })`), { on: "," })}]).readonly()`;
-        case "Hybrid":
-            return code `${this.reusables.imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.members.map(({ primaryDiscriminantValue, type }, memberI) => {
-                switch (discriminant.memberValues[memberI].kind) {
-                    case "Extrinsic":
-                        return code `${this.reusables.imports.z}.object({ ${discriminant.name}: ${this.reusables.imports.z}.literal(${literalOf(primaryDiscriminantValue)}), value: ${type.jsonSchema({ context: "type" })} })`;
-                    case "Intrinsic":
-                        return type.jsonSchema({
-                            includeDiscriminantProperty: true,
-                            context: "type",
-                        });
-                    default:
-                        throw new Error();
-                }
-            }), { on: "," })}]).readonly()`;
-        case "Intrinsic":
-            return code `${this.reusables.imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.members.map(({ type }) => type.jsonSchema({
-                includeDiscriminantProperty: true,
-                context: "type",
-            })), { on: "," })}]).readonly()`;
-        case "Typeof":
-            return code `${this.reusables.imports.z}.union([${joinCode(this.members.map(({ type }) => type.jsonSchema({ context: "type" })), { on: "," })}]).readonly()`;
-        default:
-            throw discriminant;
-    }
-}
-//# sourceMappingURL=AbstractDiscriminatedUnionType_jsonSchemaExpression.js.map

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

@@ -1,5 +0,0 @@
-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/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_jsonTypeLiteral.js

@@ -1,26 +0,0 @@
-import { AbstractType } from "../AbstractType.js";
-import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
-export function AbstractDiscriminatedUnionType_jsonTypeLiteral() {
-    const discriminant = this.discriminant; // To get type narrowing to work
-    switch (discriminant.kind) {
-        case "Extrinsic":
-            return new AbstractType.JsonType(code `(${joinCode(this.members.map(({ jsonType, primaryDiscriminantValue }) => code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${jsonType} }`), { on: "|" })})`);
-        case "Hybrid":
-            return new AbstractType.JsonType(code `(${joinCode(this.members.map(({ jsonType, primaryDiscriminantValue }, memberI) => {
-                switch (discriminant.memberValues[memberI].kind) {
-                    case "Extrinsic":
-                        return code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${jsonType} }`;
-                    case "Intrinsic":
-                        return code `${jsonType}`;
-                    default:
-                        throw new Error();
-                }
-            }), { on: "|" })})`);
-        case "Intrinsic":
-        case "Typeof":
-            return new AbstractType.JsonType(joinCode(this.members.map(({ jsonType }) => code `${jsonType}`), { on: "|" }));
-        default:
-            throw discriminant;
-    }
-}
-//# sourceMappingURL=AbstractDiscriminatedUnionType_jsonTypeLiteral.js.map

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

@@ -1,5 +0,0 @@
-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/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_toJsonFunctionExpression.js

@@ -1,10 +0,0 @@
-import { code, joinCode } from "../ts-poet-wrapper.js";
-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`)))}; }`))}
-
-  throw new Error("unable to serialize to JSON");
-})`;
-}
-//# sourceMappingURL=AbstractDiscriminatedUnionType_toJsonFunctionExpression.js.map

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

@@ -1,30 +0,0 @@
-import { code, joinCode } from "../ts-poet-wrapper.js";
-export function AbstractDiscriminatedUnionType_toRdfResourceValuesFunctionExpression() {
-    return code `\
-  (((value, _options): (${joinCode([...this.toRdfResourceValueTypes].map((toRdfResourceValueType) => {
-        switch (toRdfResourceValueType) {
-            case "BlankNode":
-                return code `${this.reusables.imports.BlankNode}`;
-            case "Literal":
-                return code `${this.reusables.imports.Literal}`;
-            case "NamedNode":
-                return code `${this.reusables.imports.NamedNode}`;
-            default:
-                toRdfResourceValueType;
-                throw new Error();
-        }
-    }), { on: " | " })})[] => {
-  ${joinCode(this.members.map(({ type, unwrap, typeCheck }) => code `if (${typeCheck(code `value`)}) { return ${type.toRdfResourceValuesExpression({
-        variables: {
-            graph: code `_options.graph`,
-            propertyPath: code `_options.propertyPath`,
-            resource: code `_options.resource`,
-            resourceSet: code `_options.resourceSet`,
-            value: unwrap(code `value`),
-        },
-    })}; }`))}
-  
-    throw new Error("unable to serialize to RDF");
-  }) satisfies ${this.reusables.snippets.ToRdfResourceValuesFunction}<${this.expression}>)`;
-}
-//# sourceMappingURL=AbstractDiscriminatedUnionType_toRdfResourceValuesFunctionExpression.js.map

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

@@ -1,9 +0,0 @@
-export interface AbstractType_DiscriminantProperty {
-    readonly jsonName: string;
-    readonly name: string;
-    readonly values: readonly AbstractType_DiscriminantProperty.Value[];
-}
-export declare namespace AbstractType_DiscriminantProperty {
-    type Value = number | string;
-}
-//# sourceMappingURL=AbstractType_DiscriminantProperty.d.ts.map

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

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

package/dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_focusSparqlConstructTriplesFunctionDeclaration.js

@@ -1,13 +0,0 @@
-import { pascalCase } from "change-case";
-import { singleEntryRecord } from "../singleEntryRecord.js";
-import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectDiscriminatedUnionType_focusSparqlConstructTriplesFunctionDeclaration() {
-    if (!this.configuration.features.has("Object.SPARQL")) {
-        return {};
-    }
-    return singleEntryRecord(`focusSparqlConstructTriples`, code `\
-export function focusSparqlConstructTriples({ filter, focusIdentifier, variablePrefix }: { filter: ${this.filterType} | undefined; focusIdentifier: ${this.reusables.imports.NamedNode} | ${this.reusables.imports.Variable}; ignoreRdfType: boolean; variablePrefix: string }): readonly ${this.reusables.imports.sparqljs}.Triple[] {
-  return [${joinCode(this.members.map((member) => code `...${member.type.name.unsafeCoerce()}.focusSparqlConstructTriples({ filter: filter?.on?.${member.primaryDiscriminantValue}, focusIdentifier, ignoreRdfType: false, variablePrefix: \`\${variablePrefix}${pascalCase(member.type.name.unsafeCoerce())}\` }).concat()`), { on: ", " })}];
-}`);
-}
-//# sourceMappingURL=ObjectDiscriminatedUnionType_focusSparqlConstructTriplesFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_focusSparqlWherePatternsFunctionDeclaration.js

@@ -1,32 +0,0 @@
-import { pascalCase } from "change-case";
-import { singleEntryRecord } from "../singleEntryRecord.js";
-import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
-export function ObjectDiscriminatedUnionType_focusSparqlWherePatternsFunctionDeclaration() {
-    if (!this.configuration.features.has("Object.SPARQL")) {
-        return {};
-    }
-    return singleEntryRecord(`focusSparqlWherePatterns`, code `\
-export function focusSparqlWherePatterns({ filter, focusIdentifier, preferredLanguages, variablePrefix }: { filter: ${this.filterType} | undefined; focusIdentifier: ${this.reusables.imports.NamedNode} | ${this.reusables.imports.Variable}; ignoreRdfType: boolean; preferredLanguages: readonly string[] | undefined; variablePrefix: string }): readonly ${this.reusables.snippets.SparqlPattern}[] {
-${joinCode([
-        code `let patterns: ${this.reusables.snippets.SparqlPattern}[] = [];`,
-        code `\
-if (focusIdentifier.termType === "Variable") {
-  patterns = patterns.concat(${this.identifierType.unsafeCoerce().valueSparqlWherePatternsFunction}({
-      filter: filter?.${this.configuration.syntheticNamePrefix}identifier,
-      ignoreRdfType: false,
-      preferredLanguages,
-      propertyPatterns: [],
-      schema: ${this.identifierType.unsafeCoerce().schema},
-      valueVariable: focusIdentifier,
-      variablePrefix,
-  }));
-}`,
-        code `patterns.push({ patterns: [${joinCode(this.members.map((member) => code `${{
-            patterns: code `${member.type.name.unsafeCoerce()}.focusSparqlWherePatterns({ filter: filter?.on?.${member.primaryDiscriminantValue}, focusIdentifier, ignoreRdfType: false, preferredLanguages, variablePrefix: \`\${variablePrefix}${pascalCase(member.type.name.unsafeCoerce())}\` }).concat()`,
-            type: literalOf("group"),
-        }}`), { on: ", " })}], type: "union" });`,
-        code `return patterns;`,
-    ])}
-}`);
-}
-//# sourceMappingURL=ObjectDiscriminatedUnionType_focusSparqlWherePatternsFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_fromRdfResourceFunctionDeclaration.js

@@ -1,17 +0,0 @@
-import { singleEntryRecord } from "../singleEntryRecord.js";
-import { code } from "../ts-poet-wrapper.js";
-export function ObjectDiscriminatedUnionType_fromRdfResourceFunctionDeclaration() {
-    if (!this.configuration.features.has("Object.fromRdf")) {
-        return {};
-    }
-    const name = this.name.unsafeCoerce();
-    return singleEntryRecord(`fromRdfResource`, code `\
-export const fromRdfResource: ${this.reusables.snippets.FromRdfResourceFunction}<${name}> = (resource, options) => 
-  ${this.members.reduce((expression, member) => {
-        const memberTypeExpression = code `(${member.type.name.unsafeCoerce()}.fromRdfResource(resource, { ...options, ignoreRdfType: false }) as ${this.reusables.imports.Either}<Error, ${name}>)`;
-        return expression !== null
-            ? code `${expression}.altLazy(() => ${memberTypeExpression})`
-            : memberTypeExpression;
-    }, null)};`);
-}
-//# sourceMappingURL=ObjectDiscriminatedUnionType_fromRdfResourceFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_graphqlTypeVariableStatement.js

@@ -1,16 +0,0 @@
-import { singleEntryRecord } from "../singleEntryRecord.js";
-import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectDiscriminatedUnionType_graphqlTypeVariableStatement() {
-    if (!this.configuration.features.has("GraphQL")) {
-        return {};
-    }
-    const name = this.name.unsafeCoerce();
-    return singleEntryRecord(`GraphQL`, code `\
-export const GraphQL = new ${this.reusables.imports.GraphQLUnionType}(${{
-        description: this.comment.map(JSON.stringify).extract(),
-        name: name,
-        resolveType: code `(value: ${name}) => value.${this.configuration.syntheticNamePrefix}type`,
-        types: code `[${joinCode(this.members.map((member) => member.type.graphqlType.nullableExpression), { on: ", " })}]`,
-    }});`);
-}
-//# sourceMappingURL=ObjectDiscriminatedUnionType_graphqlTypeVariableStatement.js.map

package/dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_identifierTypeDeclarations.d.ts

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

package/dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_identifierTypeDeclarations.js

@@ -1,14 +0,0 @@
-import { singleEntryRecord } from "../singleEntryRecord.js";
-import { code } from "../ts-poet-wrapper.js";
-export function ObjectDiscriminatedUnionType_identifierTypeDeclarations() {
-    if (!this.configuration.features.has("Object.type")) {
-        return {};
-    }
-    return singleEntryRecord(`Identifier`, code `\
-export type Identifier = ${this.identifierType.unsafeCoerce().expression};
-export namespace Identifier {
-  export const parse = ${this.identifierType.unsafeCoerce().parseFunction};
-  export const stringify = ${this.identifierType.unsafeCoerce().stringifyFunction};
-}`);
-}
-//# sourceMappingURL=ObjectDiscriminatedUnionType_identifierTypeDeclarations.js.map

package/dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_schemaVariableStatement.d.ts

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

package/dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_toRdfResourceFunctionDeclaration.js

@@ -1,15 +0,0 @@
-import { singleEntryRecord } from "../singleEntryRecord.js";
-import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectDiscriminatedUnionType_toRdfResourceFunctionDeclaration() {
-    if (!this.configuration.features.has("Object.toRdf")) {
-        return {};
-    }
-    const name = this.name.unsafeCoerce();
-    return singleEntryRecord(`toRdfResource`, code `\
-export const toRdfResource: ${this.reusables.snippets.ToRdfResourceFunction}<${name}> = (object, options) => {
-${joinCode(this.members
-        .map((member) => code `if (${member.type.name.unsafeCoerce()}.is${member.type.name.unsafeCoerce()}(object)) { return ${member.type.name.unsafeCoerce()}.toRdfResource(object, options); }`)
-        .concat(code `throw new Error("unrecognized type");`))}
-};`);
-}
-//# sourceMappingURL=ObjectDiscriminatedUnionType_toRdfResourceFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_typeGuardFunctionDeclaration.js

@@ -1,16 +0,0 @@
-import { singleEntryRecord } from "../singleEntryRecord.js";
-import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectDiscriminatedUnionType_typeGuardFunctionDeclaration() {
-    if (!this.configuration.features.has("Object.type")) {
-        return {};
-    }
-    const name = this.name.extract();
-    if (!name) {
-        return {};
-    }
-    return singleEntryRecord(`is${name}`, code `\
-    export function is${name}(object: ${this.configuration.syntheticNamePrefix}Object): object is ${name} {
-      return ${joinCode(this.members.map((member) => code `${member.type.name.unsafeCoerce()}.is${member.type.name.unsafeCoerce()}(object)`), { on: " || " })};
-    }`);
-}
-//# sourceMappingURL=ObjectDiscriminatedUnionType_typeGuardFunctionDeclaration.js.map

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

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

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

@@ -1,29 +0,0 @@
-import { invariant } from "ts-invariant";
-import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
-export function ObjectType_createFunctionExpression() {
-    const parametersVariable = code `${this.constructorParameters.variable}${this.constructorParameters.hasQuestionToken ? "?" : ""}`;
-    const propertyInitializers = this.properties.flatMap((property) => property
-        .constructorInitializer({
-        variables: { parameters: parametersVariable },
-    })
-        .toList());
-    invariant(propertyInitializers.length > 0);
-    let returnExpression = code `${this.reusables.snippets.sequenceRecord}({ ${joinCode(propertyInitializers, { on: "," })} })`;
-    this.discriminantProperty.ifJust((discriminantProperty) => {
-        returnExpression = code `${returnExpression}.map(properties => ({ ...properties, ${discriminantProperty.name}: ${literalOf(discriminantProperty.value)} as const }))`;
-    });
-    const monkeyPatchMethods = {};
-    if (this.configuration.features.has("Object.toJson")) {
-        monkeyPatchMethods["toJson"] = this.toJsonFunction;
-    }
-    if (this.configuration.features.has("Object.toString")) {
-        monkeyPatchMethods[`${this.configuration.syntheticNamePrefix}toString`] =
-            this.toStringFunction;
-    }
-    if (Object.keys(monkeyPatchMethods).length > 0) {
-        returnExpression = code `${returnExpression}.map(object => ${this.reusables.snippets.monkeyPatchObject}(object, ${monkeyPatchMethods}))`;
-    }
-    const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
-    return code `(<${syntheticNamePrefix}DefaultNamespaceT extends ${this.reusables.snippets.NamespaceBuilder} = ${this.reusables.snippets.NamespaceBuilder}>(${parametersVariable}: ${this.constructorParameters.type.expression})${this.name.map((name) => code `: ${this.reusables.imports.Either}<Error, ${name}>`).orDefault(code ``)} => ${returnExpression})`;
-}
-//# sourceMappingURL=ObjectType_createFunctionExpression.js.map

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

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

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

@@ -1,12 +0,0 @@
-import { invariant } from "ts-invariant";
-import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectType_fromJsonFunctionExpression() {
-    const variables = {
-        jsonObject: code `${this.configuration.syntheticNamePrefix}json`,
-    };
-    const propertyInitializers = this.properties.flatMap((property) => property.fromJsonInitializer({ variables }).toList());
-    invariant(propertyInitializers.length > 0);
-    return code `\
-((${variables.jsonObject}) => ${this.reusables.snippets.sequenceRecord}({ ${joinCode(propertyInitializers, { on: "," })} }).chain(${this.createFunction}))`;
-}
-//# sourceMappingURL=ObjectType_fromJsonFunctionExpression.js.map

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

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

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

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

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

@@ -1,10 +0,0 @@
-import { code } from "../ts-poet-wrapper.js";
-export function ObjectType_jsonParseFunctionDeclaration() {
-    return code `\
-export function parse(json: unknown): ${this.reusables.imports.Either}<Error, Json> {
-  const jsonSafeParseResult = schema().safeParse(json);
-  if (!jsonSafeParseResult.success) { return ${this.reusables.imports.Left}(jsonSafeParseResult.error); }
-  return ${this.reusables.imports.Right}(jsonSafeParseResult.data);
-}`;
-}
-//# sourceMappingURL=ObjectType_jsonParseFunctionDeclaration.js.map

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

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

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

@@ -1,22 +0,0 @@
-import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectType_jsonSchemaExpression() {
-    const properties = this.properties
-        .flatMap((property) => property.jsonSchema.toList())
-        .map(({ key, schema }) => code `"${key}": ${schema}`);
-    // ${this.properties.every((property) => !property.mutable) ? `.readonly()` : ""}
-    let expression = code `${this.reusables.imports.z}.object({${joinCode(properties, { on: "," })}})`;
-    const meta = {
-    // id: this.name,
-    };
-    this.comment.ifJust((description) => {
-        meta["description"] = description;
-    });
-    this.label.ifJust((label) => {
-        meta["title"] = label;
-    });
-    if (Object.keys(meta).length > 0) {
-        expression = code `${expression}.meta(${meta})`;
-    }
-    return expression;
-}
-//# sourceMappingURL=ObjectType_jsonSchemaExpression.js.map

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

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

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

@@ -1,5 +0,0 @@
-import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectType_jsonTypeExpression() {
-    return code `{ ${joinCode(this.properties.flatMap((property) => property.jsonSignature.toList()), { on: ";" })} }`;
-}
-//# sourceMappingURL=ObjectType_jsonTypeExpression.js.map

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

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

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

@@ -1,17 +0,0 @@
-import { arrayOf, code, literalOf } from "../ts-poet-wrapper.js";
-export function ObjectType_jsonUiSchemaFunctionExpression() {
-    const variables = { scopePrefix: code `scopePrefix` };
-    const uiSchema = {
-        elements: code `${arrayOf(...this.properties.flatMap((property) => property.jsonUiSchemaElement({ variables }).toList()))}`,
-        type: "Group",
-    };
-    this.name.ifJust((name) => {
-        uiSchema["label"] = code `${literalOf(name)}`;
-    });
-    return code `\
-((parameters?: { scopePrefix?: string }): any => {
-  const scopePrefix = parameters?.scopePrefix ?? "#";
-  return ${uiSchema};
-})`;
-}
-//# sourceMappingURL=ObjectType_jsonUiSchemaFunctionExpression.js.map

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

@@ -1,10 +0,0 @@
-import type { Reusables } from "../Reusables.js";
-import type { TsGenerator } from "../TsGenerator.js";
-import { type Code } from "../ts-poet-wrapper.js";
-export declare function ObjectType_sparqlConstructQueryFunctionDeclaration(this: {
-    readonly name: string;
-    readonly configuration: TsGenerator.Configuration;
-    readonly filterType: Code;
-    readonly reusables: Reusables;
-}): Code;
-//# sourceMappingURL=ObjectType_sparqlConstructQueryFunctionDeclaration.d.ts.map

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

@@ -1,35 +0,0 @@
-import { camelCase } from "change-case";
-import { code } from "../ts-poet-wrapper.js";
-export function ObjectType_sparqlConstructQueryFunctionDeclaration() {
-    return code `\
-export function sparqlConstructQuery({ filter, ignoreRdfType, preferredLanguages, prefixes, subject, ...queryParameters }: { filter?: ${this.filterType}; ignoreRdfType?: boolean; prefixes?: { [prefix: string]: string }; preferredLanguages?: readonly string[]; subject: ${this.reusables.imports.NamedNode} | ${this.reusables.imports.Variable} } & Omit<${this.reusables.imports.sparqljs}.ConstructQuery, "prefixes" | "queryType" | "type">): ${this.reusables.imports.sparqljs}.ConstructQuery {
-  const variablePrefix = subject.termType === "Variable" ? subject.value : "${camelCase(this.name)}";
-
-  return {
-    ...queryParameters,
-    prefixes: prefixes ?? {},
-    queryType: "CONSTRUCT",
-    template: (queryParameters.template ?? []).concat(
-      ${this.name}.focusSparqlConstructTriples({
-        filter,
-        focusIdentifier: subject,
-        ignoreRdfType: !!ignoreRdfType,
-        variablePrefix
-      })
-    ),
-    type: "query",
-    where: (queryParameters.where ?? []).concat(
-      ${this.reusables.snippets.normalizeSparqlWherePatterns}(
-        ${this.name}.focusSparqlWherePatterns({
-          filter,
-          focusIdentifier: subject,
-          ignoreRdfType: !!ignoreRdfType,
-          preferredLanguages,
-          variablePrefix
-        })
-      )
-    )
-  };
-}`;
-}
-//# sourceMappingURL=ObjectType_sparqlConstructQueryFunctionDeclaration.js.map

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

@@ -1,8 +0,0 @@
-import { code } from "../ts-poet-wrapper.js";
-export function ObjectType_sparqlConstructQueryStringFunctionDeclaration() {
-    return code `\
-export function sparqlConstructQueryString(parameters: Parameters<typeof ${this.name}.sparqlConstructQuery>[0] & ${this.reusables.imports.sparqljs}.GeneratorOptions): string {
-  return new ${this.reusables.imports.sparqljs}.Generator(parameters).stringify(${this.name}.sparqlConstructQuery(parameters));
-}`;
-}
-//# sourceMappingURL=ObjectType_sparqlConstructQueryStringFunctionDeclaration.js.map

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

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

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

@@ -1,12 +0,0 @@
-import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectType_toJsonFunctionExpression() {
-    return code `\
-((${this.thisVariable}) => JSON.parse(JSON.stringify({ ${joinCode(this.properties.flatMap((property) => property
-        .toJsonInitializer({
-        variables: {
-            object: this.thisVariable,
-        },
-    })
-        .toList()), { on: "," })} } satisfies ${this.jsonType().expression})))`;
-}
-//# sourceMappingURL=ObjectType_toJsonFunctionExpression.js.map

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

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

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

@@ -1,26 +0,0 @@
-import { rdf } from "@tpluscode/rdf-ns-builders";
-import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectType_toRdfResourceFunctionExpression() {
-    const statements = [];
-    this.toRdfTypesVariable.ifJust((toRdfTypesVariable) => {
-        statements.push(code `if (!${variables.ignoreRdfType}) { ${variables.resource}.add(${this.rdfjsTermExpression(rdf.type)}, ${toRdfTypesVariable}, ${variables.graph}); }`);
-    });
-    for (const property of this.properties) {
-        statements.push(...property.toRdfRdfResourceValuesStatements({
-            variables,
-        }));
-    }
-    statements.push(code `return ${variables.resource};`);
-    return code `\
-((parameters) => {
-  ${joinCode(statements)}
-})`;
-}
-const variables = {
-    ignoreRdfType: code `parameters.ignoreRdfType`,
-    graph: code `parameters.graph`,
-    object: code `parameters.object`,
-    resource: code `parameters.resource`,
-    resourceSet: code `parameters.resourceSet`,
-};
-//# sourceMappingURL=ObjectType_toRdfResourceFunctionExpression.js.map

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

@@ -1,7 +0,0 @@
-import { code } from "../ts-poet-wrapper.js";
-export function ObjectType_toStringFunctionExpression() {
-    return this.name
-        .map((name) => code `((${this.thisVariable}) => \`${name}(\${JSON.stringify(toStringRecord(${this.thisVariable}))})\`)`)
-        .orDefault(code `((${this.thisVariable}) => JSON.stringify(${this.toStringRecordExpression({ variables: { value: this.thisVariable } })}))`);
-}
-//# sourceMappingURL=ObjectType_toStringFunctionExpression.js.map

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

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

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

@@ -1,5 +0,0 @@
-import { code } from "../ts-poet-wrapper.js";
-export function ObjectType_toStringRecordFunctionExpression() {
-    return code `((${this.thisVariable}) => ${this.toStringRecordExpression({ variables: { value: this.thisVariable } })})`;
-}
-//# sourceMappingURL=ObjectType_toStringRecordFunctionExpression.js.map

package/dist/generators/ts/_ObjectType/ObjectType_typeGuardFunctionExpression.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_typeGuardFunctionExpression(this: ObjectType): Maybe<Code>;
-//# sourceMappingURL=ObjectType_typeGuardFunctionExpression.d.ts.map

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

@@ -1,14 +0,0 @@
-import { Maybe } from "purify-ts";
-import { code, literalOf } from "../ts-poet-wrapper.js";
-export function ObjectType_typeGuardFunctionExpression() {
-    if (!this.configuration.features.has("Object.type")) {
-        return Maybe.empty();
-    }
-    const discriminantProperty = this.discriminantProperty.extract();
-    if (!discriminantProperty) {
-        return Maybe.empty();
-    }
-    return Maybe.of(code `\
-(object: ${this.configuration.syntheticNamePrefix}Object): object is ${this.expression} => object.${discriminantProperty.name} === ${literalOf(discriminantProperty.value)}`);
-}
-//# sourceMappingURL=ObjectType_typeGuardFunctionExpression.js.map