@shaclmate/compiler 4.0.39 → 4.0.40

package/dist/generators/ts/AbstractNamedUnionType.js

@@ -1,190 +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 } from "purify-ts";
-import { Memoize } from "typescript-memoize";
-import { AbstractType } from "./AbstractType.js";
-import { AbstractUnionType } from "./AbstractUnionType.js";
-import { code, def, joinCode } from "./ts-poet-wrapper.js";
-export class AbstractNamedUnionType extends AbstractUnionType {
-    _name;
-    constructor({ name, ...superParameters }) {
-        super(superParameters);
-        this._name = name;
-    }
-    get declaration() {
-        const declarations = [];
-        if (this.configuration.features.has("Object.type")) {
-            declarations.push(code `export type ${def(this._name)} = ${this.inlineName};`);
-        }
-        const staticModuleDeclarations = Object.entries(this.staticModuleDeclarations);
-        if (staticModuleDeclarations.length > 0) {
-            declarations.push(code `\
-export namespace ${def(this.name)} {
-${joinCode(staticModuleDeclarations
-                .sort((left, right) => left[0].localeCompare(right[0]))
-                .map((_) => _[1]), { on: "\n\n" })}
-}`);
-        }
-        return Maybe.of(joinCode(declarations, { on: "\n\n" }));
-    }
-    get equalsFunction() {
-        return code `${this.name}.equals`;
-    }
-    get filterFunction() {
-        return code `${this.name}.filter`;
-    }
-    get filterType() {
-        return code `${this.name}.Filter`;
-    }
-    get hashFunction() {
-        return code `${this.name}.hash`;
-    }
-    get jsonSchemaFunctionDeclaration() {
-        const meta = {
-        // id: this.name,
-        };
-        this.comment.ifJust((description) => {
-            meta["description"] = description;
-        });
-        this.label.ifJust((label) => {
-            meta["title"] = label;
-        });
-        return code `export const schema = () => ${this.inlineJsonSchema}.meta(${meta});`;
-    }
-    get jsonTypeAliasDeclaration() {
-        return code `export type Json = ${this.inlineJsonType.name}`;
-    }
-    get name() {
-        return this._name;
-    }
-    get valueSparqlConstructTriplesFunction() {
-        return code `${this.name}.valueSparqlConstructTriples`;
-    }
-    get valueSparqlWherePatternsFunction() {
-        return code `${this.name}.valueSparqlWherePatterns`;
-    }
-    get staticModuleDeclarations() {
-        const staticModuleDeclarations = {};
-        if (this.configuration.features.has("Object.equals")) {
-            staticModuleDeclarations[`equals`] =
-                code `export const equals = ${this.inlineEqualsFunction};`;
-        }
-        if (this.configuration.features.has("Object.filter")) {
-            staticModuleDeclarations[`Filter`] =
-                code `export type Filter = ${this.inlineFilterType};`;
-            staticModuleDeclarations[`filter`] =
-                code `export const filter = ${this.inlineFilterFunction};`;
-        }
-        if (this.configuration.features.has("Object.hash")) {
-            staticModuleDeclarations[`hash`] =
-                code `export const hash = ${this.inlineHashFunction};`;
-        }
-        if (this.configuration.features.has("Object.JSON.type")) {
-            staticModuleDeclarations[`Json.type`] =
-                code `${this.jsonTypeAliasDeclaration}`;
-        }
-        if (this.configuration.features.has("Object.JSON.schema")) {
-            staticModuleDeclarations[`Json.namespace`] = code `\
-export namespace Json {
-  ${this.jsonSchemaFunctionDeclaration}
-
-  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);
-  }
-}`;
-        }
-        if (this.configuration.features.has("Object.fromJson")) {
-            staticModuleDeclarations[`fromJson`] =
-                code `export const fromJson = ${this.inlineFromJsonFunction};`;
-        }
-        if (this.configuration.features.has("Object.fromRdf")) {
-            staticModuleDeclarations[`fromRdfResourceValues`] =
-                code `export const fromRdfResourceValues: ${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.name}> = ${this.inlineFromRdfResourceValuesFunction};`;
-        }
-        if (this.configuration.features.has("Object.toJson")) {
-            staticModuleDeclarations[`toJson`] =
-                code `export const toJson = ${this.inlineToJsonFunction};`;
-        }
-        if (this.configuration.features.has("Object.toRdf")) {
-            staticModuleDeclarations[`toRdfResourceValues`] =
-                code `export const toRdfResourceValues = ${this.inlineToRdfResourceValuesFunction};`;
-        }
-        if (this.configuration.features.has("Object.SPARQL")) {
-            staticModuleDeclarations[`valueSparqlConstructTriples`] =
-                code `export const valueSparqlConstructTriples: ${this.reusables.snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}> = ${this.inlineValueSparqlConstructTriplesFunction};`;
-            staticModuleDeclarations[`valueSparqlWherePatterns`] =
-                code `export const valueSparqlWherePatterns: ${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}> = ${this.inlineValueSparqlWherePatternsFunction};`;
-        }
-        if (this.configuration.features.has("Object.toString")) {
-            const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
-            staticModuleDeclarations[`${syntheticNamePrefix}toString`] =
-                code `export const ${syntheticNamePrefix}toString = ${this.inlineToStringFunction};`;
-        }
-        return staticModuleDeclarations;
-    }
-    fromJsonExpression({ variables, }) {
-        return code `${this.name}.fromJson(${variables.value})`;
-    }
-    fromRdfResourceValuesExpression({ variables, }) {
-        const { resourceValues: resourceValuesVariable, ...fromRdfResourceValuesOptionsTemp } = variables;
-        const fromRdfResourceValuesOptions = fromRdfResourceValuesOptionsTemp;
-        if (!this.configuration.features.has("ObjectSet")) {
-            delete fromRdfResourceValuesOptions["objectSet"];
-        }
-        return code `${this.name}.fromRdfResourceValues(${resourceValuesVariable}, ${fromRdfResourceValuesOptions})`;
-    }
-    jsonSchema({ context, }) {
-        const expression = code `${this.name}.Json.schema()`;
-        if (context === "property" && this.recursive) {
-            return code `${this.reusables.imports.z}.lazy((): ${this.reusables.imports.z}.ZodType<${this.name}.Json> => ${expression})`;
-        }
-        return expression;
-    }
-    jsonType() {
-        return new AbstractType.JsonType(`${this.name}.Json`);
-    }
-    toJsonExpression({ variables, }) {
-        return code `${this.name}.toJson(${variables.value})`;
-    }
-    toRdfResourceValuesExpression({ variables, }) {
-        const { value: valueVariable, ...otherVariables } = variables;
-        return code `${this.name}.toRdfResourceValues(${valueVariable}, ${otherVariables})`;
-    }
-    toStringExpression({ variables, }) {
-        return code `${this.name}.${this.configuration.syntheticNamePrefix}toString(${variables.value})`;
-    }
-}
-__decorate([
-    Memoize()
-], AbstractNamedUnionType.prototype, "declaration", null);
-__decorate([
-    Memoize()
-], AbstractNamedUnionType.prototype, "equalsFunction", null);
-__decorate([
-    Memoize()
-], AbstractNamedUnionType.prototype, "filterFunction", null);
-__decorate([
-    Memoize()
-], AbstractNamedUnionType.prototype, "filterType", null);
-__decorate([
-    Memoize()
-], AbstractNamedUnionType.prototype, "hashFunction", null);
-__decorate([
-    Memoize()
-], AbstractNamedUnionType.prototype, "name", null);
-__decorate([
-    Memoize()
-], AbstractNamedUnionType.prototype, "valueSparqlConstructTriplesFunction", null);
-__decorate([
-    Memoize()
-], AbstractNamedUnionType.prototype, "valueSparqlWherePatternsFunction", null);
-__decorate([
-    Memoize()
-], AbstractNamedUnionType.prototype, "jsonType", null);
-//# sourceMappingURL=AbstractNamedUnionType.js.map

package/dist/generators/ts/AnonymousUnionType.d.ts

@@ -1,27 +0,0 @@
-import { Maybe } from "purify-ts";
-import type { AbstractType } from "./AbstractType.js";
-import { AbstractUnionType } from "./AbstractUnionType.js";
-import type { Type } from "./Type.js";
-import { type Code } from "./ts-poet-wrapper.js";
-export declare class AnonymousUnionType extends AbstractUnionType<Type> {
-    readonly declaration: Maybe<Code>;
-    readonly graphqlArgs: AbstractType["graphqlArgs"];
-    readonly kind = "AnonymousUnion";
-    get equalsFunction(): Code;
-    get filterFunction(): Code;
-    get filterType(): Code;
-    get graphqlType(): AbstractType.GraphqlType;
-    get hashFunction(): Code;
-    get name(): Code;
-    get valueSparqlConstructTriplesFunction(): Code;
-    get valueSparqlWherePatternsFunction(): Code;
-    fromJsonExpression({ variables, }: Parameters<AbstractType["fromJsonExpression"]>[0]): Code;
-    fromRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["fromRdfResourceValuesExpression"]>[0]): Code;
-    graphqlResolveExpression(_parameters: Parameters<AbstractType["graphqlResolveExpression"]>[0]): Code;
-    jsonSchema(_parameters: Parameters<AbstractType["jsonSchema"]>[0]): Code;
-    jsonType(): AbstractType.JsonType;
-    toJsonExpression({ variables, }: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
-    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
-    toStringExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
-}
-//# sourceMappingURL=AnonymousUnionType.d.ts.map

package/dist/generators/ts/AnonymousUnionType.js

@@ -1,59 +0,0 @@
-import { Maybe } from "purify-ts";
-import { AbstractUnionType } from "./AbstractUnionType.js";
-import { code } from "./ts-poet-wrapper.js";
-export class AnonymousUnionType extends AbstractUnionType {
-    declaration = Maybe.empty();
-    graphqlArgs = Maybe.empty();
-    kind = "AnonymousUnion";
-    get equalsFunction() {
-        return this.inlineEqualsFunction;
-    }
-    get filterFunction() {
-        return this.inlineFilterFunction;
-    }
-    get filterType() {
-        return this.inlineFilterType;
-    }
-    get graphqlType() {
-        throw new Error("GraphQL doesn't support scalar unions");
-    }
-    get hashFunction() {
-        return this.inlineHashFunction;
-    }
-    get name() {
-        return this.inlineName;
-    }
-    get valueSparqlConstructTriplesFunction() {
-        return this.inlineValueSparqlConstructTriplesFunction;
-    }
-    get valueSparqlWherePatternsFunction() {
-        return this.inlineValueSparqlWherePatternsFunction;
-    }
-    fromJsonExpression({ variables, }) {
-        return code `${this.inlineFromJsonFunction}(${variables.value})`;
-    }
-    fromRdfResourceValuesExpression({ variables, }) {
-        const { resourceValues: resourceValuesVariable, ...otherVariables } = variables;
-        return code `${this.inlineFromRdfResourceValuesFunction}(${resourceValuesVariable}, ${otherVariables})`;
-    }
-    graphqlResolveExpression(_parameters) {
-        throw new Error("not implemented");
-    }
-    jsonSchema(_parameters) {
-        return this.inlineJsonSchema;
-    }
-    jsonType() {
-        return this.inlineJsonType;
-    }
-    toJsonExpression({ variables, }) {
-        return code `${this.inlineToJsonFunction}(${variables.value})`;
-    }
-    toRdfResourceValuesExpression({ variables, }) {
-        const { value: valueVariable, ...otherVariables } = variables;
-        return code `${this.inlineToRdfResourceValuesFunction}(${valueVariable}, ${otherVariables})`;
-    }
-    toStringExpression({ variables, }) {
-        return code `${this.inlineToStringFunction}(${variables.value})`;
-    }
-}
-//# sourceMappingURL=AnonymousUnionType.js.map

package/dist/generators/ts/NamedObjectType.js

@@ -1,342 +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 { NodeKind } from "@shaclmate/shacl-ast";
-import { camelCase } from "change-case";
-import { Maybe } from "purify-ts";
-import { Memoize } from "typescript-memoize";
-import { DiscriminantProperty as _DiscriminantProperty } from "./_NamedObjectType/DiscriminantProperty.js";
-import { IdentifierProperty as _IdentifierProperty } from "./_NamedObjectType/IdentifierProperty.js";
-import { identifierTypeDeclarations } from "./_NamedObjectType/identifierTypeDeclarations.js";
-import { NamedObjectType_createFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_createFunctionDeclaration.js";
-import { NamedObjectType_equalsFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_equalsFunctionDeclaration.js";
-import { NamedObjectType_filterFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_filterFunctionDeclaration.js";
-import { NamedObjectType_filterTypeDeclaration } from "./_NamedObjectType/NamedObjectType_filterTypeDeclaration.js";
-import { NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration.js";
-import { NamedObjectType_focusSparqlWherePatternsFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_focusSparqlWherePatternsFunctionDeclaration.js";
-import { NamedObjectType_fromJsonFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_fromJsonFunctionDeclaration.js";
-import { NamedObjectType_fromRdfResourceFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_fromRdfResourceFunctionDeclaration.js";
-import { NamedObjectType_fromRdfResourceValuesFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_fromRdfResourceValuesFunctionDeclaration.js";
-import { NamedObjectType_fromRdfTypeVariableStatement } from "./_NamedObjectType/NamedObjectType_fromRdfTypeVariableStatement.js";
-import { NamedObjectType_graphqlTypeVariableStatement } from "./_NamedObjectType/NamedObjectType_graphqlTypeVariableStatement.js";
-import { NamedObjectType_hashFunctionDeclarations } from "./_NamedObjectType/NamedObjectType_hashFunctionDeclarations.js";
-import { NamedObjectType_interfaceDeclaration } from "./_NamedObjectType/NamedObjectType_interfaceDeclaration.js";
-import { NamedObjectType_isTypeFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_isTypeFunctionDeclaration.js";
-import { NamedObjectType_jsonParseFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_jsonParseFunctionDeclaration.js";
-import { NamedObjectType_jsonSchemaFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_jsonSchemaFunctionDeclaration.js";
-import { NamedObjectType_jsonTypeAliasDeclaration } from "./_NamedObjectType/NamedObjectType_jsonTypeAliasDeclaration.js";
-import { NamedObjectType_jsonUiSchemaFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_jsonUiSchemaFunctionDeclaration.js";
-import { NamedObjectType_objectSetMethodNames } from "./_NamedObjectType/NamedObjectType_objectSetMethodNames.js";
-import { NamedObjectType_schemaVariableStatement } from "./_NamedObjectType/NamedObjectType_schemaVariableStatement.js";
-import { NamedObjectType_sparqlConstructQueryFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_sparqlConstructQueryFunctionDeclaration.js";
-import { NamedObjectType_sparqlConstructQueryStringFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.js";
-import { NamedObjectType_toJsonFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_toJsonFunctionDeclaration.js";
-import { NamedObjectType_toRdfResourceFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_toRdfResourceFunctionDeclaration.js";
-import { NamedObjectType_toStringFunctionDeclarations } from "./_NamedObjectType/NamedObjectType_toStringFunctionDeclarations.js";
-import { NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration.js";
-import { NamedObjectType_valueSparqlWherePatternsFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_valueSparqlWherePatternsFunctionDeclaration.js";
-import { ShaclProperty as _ShaclProperty } from "./_NamedObjectType/ShaclProperty.js";
-import { AbstractType } from "./AbstractType.js";
-import { code, def, joinCode } from "./ts-poet-wrapper.js";
-export class NamedObjectType extends AbstractType {
-    toRdfTypes;
-    conversionFunction = Maybe.empty();
-    extern;
-    fromRdfType;
-    graphqlArgs = Maybe.empty();
-    identifierType;
-    kind = "NamedObjectType";
-    name;
-    recursive;
-    referencesObjectType = true;
-    synthetic;
-    typeofs = ["object"];
-    validationFunction = Maybe.empty();
-    constructor({ extern, fromRdfType, identifierType, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyDiscriminantProperty, lazyParentObjectTypes, lazyProperties, name, recursive, synthetic, toRdfTypes, ...superParameters }) {
-        super(superParameters);
-        this.extern = extern;
-        this.fromRdfType = fromRdfType;
-        this.identifierType = identifierType;
-        // Lazily initialize some members in getters to avoid recursive construction
-        this.lazyAncestorObjectTypes = lazyAncestorObjectTypes;
-        this.lazyChildObjectTypes = lazyChildObjectTypes;
-        this.lazyDescendantObjectTypes = lazyDescendantObjectTypes;
-        this.lazyDiscriminantProperty = lazyDiscriminantProperty;
-        this.lazyParentObjectTypes = lazyParentObjectTypes;
-        this.lazyProperties = lazyProperties;
-        this.name = name;
-        this.recursive = recursive;
-        this.synthetic = synthetic;
-        this.toRdfTypes = toRdfTypes;
-    }
-    get _discriminantProperty() {
-        return this.lazyDiscriminantProperty(this);
-    }
-    get ancestorObjectTypes() {
-        return this.lazyAncestorObjectTypes();
-    }
-    get childObjectTypes() {
-        return this.lazyChildObjectTypes();
-    }
-    get declaration() {
-        const declarations = [];
-        if (!this.extern) {
-            const staticModuleDeclarations = [];
-            if (this.configuration.features.has("Object.type")) {
-                declarations.push(NamedObjectType_interfaceDeclaration.call(this));
-            }
-            staticModuleDeclarations.push(...NamedObjectType_createFunctionDeclaration.call(this).toList(), ...NamedObjectType_equalsFunctionDeclaration.call(this).toList(), ...NamedObjectType_hashFunctionDeclarations.call(this));
-            const jsonModuleDeclarations = [
-                ...NamedObjectType_jsonParseFunctionDeclaration.call(this).toList(),
-                ...NamedObjectType_jsonSchemaFunctionDeclaration.call(this).toList(),
-                ...NamedObjectType_jsonUiSchemaFunctionDeclaration.call(this).toList(),
-            ];
-            staticModuleDeclarations.push(...NamedObjectType_graphqlTypeVariableStatement.call(this).toList(), ...identifierTypeDeclarations.call(this), ...NamedObjectType_jsonTypeAliasDeclaration.call(this).toList(), ...(jsonModuleDeclarations.length > 0
-                ? [
-                    code `export namespace Json { ${joinCode(jsonModuleDeclarations, { on: "\n\n" })} }`,
-                ]
-                : []), ...NamedObjectType_filterFunctionDeclaration.call(this).toList(), ...NamedObjectType_filterTypeDeclaration.call(this).toList(), ...NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration.call(this).toList(), ...NamedObjectType_focusSparqlWherePatternsFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromJsonFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfResourceFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfResourceValuesFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfTypeVariableStatement.call(this).toList(), ...NamedObjectType_isTypeFunctionDeclaration.call(this).toList(), ...NamedObjectType_schemaVariableStatement.call(this).toList(), ...NamedObjectType_sparqlConstructQueryFunctionDeclaration.call({
-                configuration: this.configuration,
-                filterType: this.filterType,
-                name: this.name,
-                reusables: this.reusables,
-            }).toList(), ...NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.call({
-                configuration: this.configuration,
-                filterType: this.filterType,
-                name: this.name,
-                reusables: this.reusables,
-            }).toList(), ...NamedObjectType_toJsonFunctionDeclaration.call(this).toList(), ...NamedObjectType_toRdfResourceFunctionDeclaration.call(this).toList(), ...NamedObjectType_toStringFunctionDeclarations.call(this), ...NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration.call(this).toList(), ...NamedObjectType_valueSparqlWherePatternsFunctionDeclaration.call(this).toList());
-            if (staticModuleDeclarations.length > 0) {
-                declarations.push(code `\
-export namespace ${def(this.name)} {
-${joinCode(staticModuleDeclarations, { on: "\n\n" })}
-}`);
-            }
-        }
-        if (declarations.length === 0) {
-            return Maybe.empty();
-        }
-        return Maybe.of(joinCode(declarations, { on: "\n\n" }));
-    }
-    get descendantFromRdfTypeVariables() {
-        return this.descendantObjectTypes.flatMap((descendantObjectType) => descendantObjectType.fromRdfTypeVariable.toList());
-    }
-    get descendantFromRdfTypes() {
-        return this.descendantObjectTypes.flatMap((descendantObjectType) => descendantObjectType.fromRdfType.toList());
-    }
-    get descendantObjectTypes() {
-        return this.lazyDescendantObjectTypes();
-    }
-    get discriminantProperty() {
-        return Maybe.of({
-            jsonName: this._discriminantProperty.jsonName,
-            name: this._discriminantProperty.name,
-            ownValues: this._discriminantProperty.type.ownValues,
-            descendantValues: this._discriminantProperty.type.descendantValues,
-        });
-    }
-    get discriminantValue() {
-        return this.name;
-    }
-    get equalsFunction() {
-        return code `${this.name}.equals`;
-    }
-    get filterFunction() {
-        return code `${this.name}.filter`;
-    }
-    get filterType() {
-        return code `${this.name}.Filter`;
-    }
-    get fromRdfTypeVariable() {
-        return this.fromRdfType.map(() => code `${this.name}.fromRdfType`);
-    }
-    get graphqlType() {
-        return new AbstractType.GraphqlType(code `${this.name}.GraphQL`, this.reusables);
-    }
-    get hashFunction() {
-        return code `${this.name}.hash`;
-    }
-    get identifierTypeAlias() {
-        return code `${this.name}.Identifier`;
-    }
-    get mutable() {
-        return this.properties.some((property) => property.mutable);
-    }
-    get objectSetMethodNames() {
-        return NamedObjectType_objectSetMethodNames.call({
-            configuration: this.configuration,
-            name: this.name,
-        });
-    }
-    get parentObjectTypes() {
-        return this.lazyParentObjectTypes();
-    }
-    get properties() {
-        const properties = this.lazyProperties(this);
-        const propertyNames = new Set();
-        for (const property of properties) {
-            if (propertyNames.has(property.name)) {
-                throw new Error(`duplicate property '${property.name}'`);
-            }
-        }
-        return properties;
-    }
-    get schema() {
-        return code `${this.name}.schema`;
-    }
-    get schemaType() {
-        return code `typeof ${this.schema}`;
-    }
-    get toRdfResourceValueTypes() {
-        return new Set([...this.identifierType.nodeKinds].map(NodeKind.toTermType));
-    }
-    get toRdfjsResourceType() {
-        if (this.parentObjectTypes.length > 0) {
-            return this.parentObjectTypes[0].toRdfjsResourceType;
-        }
-        return code `${this.reusables.imports.Resource}${this.identifierType.kind === "Iri" ? code `<${this.reusables.imports.NamedNode}>` : ""}`;
-    }
-    get valueSparqlConstructTriplesFunction() {
-        return code `${this.name}.valueSparqlConstructTriples`;
-    }
-    get valueSparqlWherePatternsFunction() {
-        return code `${this.name}.valueSparqlWherePatterns`;
-    }
-    get thisVariable() {
-        return code `_${camelCase(this.name)}`;
-    }
-    fromJsonExpression({ variables, }) {
-        // Assumes the JSON object has been recursively validated already.
-        return code `${this.name}.fromJson(${variables.value})`;
-    }
-    fromRdfResourceValuesExpression({ variables, }) {
-        const { resourceValues: resourceValuesVariable, ...fromRdfResourceValuesOptionsTemp } = variables;
-        const fromRdfResourceValuesOptions = fromRdfResourceValuesOptionsTemp;
-        if (!this.configuration.features.has("ObjectSet")) {
-            delete fromRdfResourceValuesOptions["objectSet"];
-        }
-        return code `${this.name}.fromRdfResourceValues(${resourceValuesVariable}, ${fromRdfResourceValuesOptions})`;
-    }
-    graphqlResolveExpression({ variables, }) {
-        return variables.value;
-    }
-    jsonSchema({ context, }) {
-        let expression = code `${this.name}.Json.schema()`;
-        if (context === "property" &&
-            this.properties.some((property) => property.recursive)) {
-            expression = code `${this.reusables.imports.z}.lazy((): ${this.reusables.imports.z}.ZodType<${this.name}.Json> => ${expression})`;
-        }
-        return expression;
-    }
-    jsonType() {
-        return new AbstractType.JsonType(code `${this.name}.Json`);
-    }
-    jsonUiSchemaElement({ variables, }) {
-        return Maybe.of(code `${this.name}.Json.uiSchema({ scopePrefix: ${variables.scopePrefix} })`);
-    }
-    toJsonExpression({ variables, }) {
-        return code `${this.name}.toJson(${variables.value})`;
-    }
-    toRdfResourceValuesExpression({ variables, }) {
-        return code `[${this.name}.toRdfResource(${variables.value}, { graph: ${variables.graph}, resourceSet: ${variables.resourceSet} }).identifier]`;
-    }
-    toStringExpression({ variables, }) {
-        return code `${this.name}.${this.configuration.syntheticNamePrefix}toString(${variables.value})`;
-    }
-    lazyAncestorObjectTypes;
-    lazyChildObjectTypes;
-    lazyDescendantObjectTypes;
-    lazyDiscriminantProperty;
-    lazyParentObjectTypes;
-    lazyProperties;
-}
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "_discriminantProperty", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "ancestorObjectTypes", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "childObjectTypes", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "descendantFromRdfTypeVariables", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "descendantFromRdfTypes", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "descendantObjectTypes", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "discriminantProperty", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "discriminantValue", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "equalsFunction", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "filterFunction", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "filterType", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "fromRdfTypeVariable", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "graphqlType", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "hashFunction", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "identifierTypeAlias", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "mutable", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "objectSetMethodNames", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "parentObjectTypes", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "properties", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "schema", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "schemaType", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "toRdfResourceValueTypes", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "toRdfjsResourceType", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "valueSparqlConstructTriplesFunction", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "valueSparqlWherePatternsFunction", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "thisVariable", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "jsonType", null);
-(function (NamedObjectType) {
-    NamedObjectType.IdentifierProperty = _IdentifierProperty;
-    NamedObjectType.ShaclProperty = _ShaclProperty;
-    NamedObjectType.DiscriminantProperty = _DiscriminantProperty;
-})(NamedObjectType || (NamedObjectType = {}));
-//# sourceMappingURL=NamedObjectType.js.map

package/dist/generators/ts/NamedObjectUnionType.d.ts

@@ -1,37 +0,0 @@
-import { AbstractNamedUnionType } from "./AbstractNamedUnionType.js";
-import { AbstractType } from "./AbstractType.js";
-import type { BlankNodeType } from "./BlankNodeType.js";
-import type { IdentifierType } from "./IdentifierType.js";
-import type { IriType } from "./IriType.js";
-import type { NamedObjectType } from "./NamedObjectType.js";
-import { type Code } from "./ts-poet-wrapper.js";
-export declare class NamedObjectUnionType extends AbstractNamedUnionType<NamedObjectType> {
-    #private;
-    readonly graphqlArgs: AbstractType["graphqlArgs"];
-    readonly kind = "NamedObjectUnion";
-    readonly synthetic: boolean;
-    constructor({ identifierType, synthetic, ...superParameters }: {
-        identifierType: BlankNodeType | IdentifierType | IriType;
-        synthetic: boolean;
-    } & Omit<ConstructorParameters<typeof AbstractNamedUnionType<NamedObjectType>>[0], "identifierType">);
-    get graphqlType(): AbstractType.GraphqlType;
-    get identifierTypeAlias(): Code;
-    get objectSetMethodNames(): NamedObjectType.ObjectSetMethodNames;
-    get schema(): Code;
-    get schemaType(): Code;
-    protected get staticModuleDeclarations(): Record<string, Code>;
-    private get focusSparqlConstructTriplesFunctionDeclaration();
-    private get focusSparqlWherePatternsFunctionDeclaration();
-    private get fromRdfResourceFunctionDeclaration();
-    private get graphqlTypeVariableStatement();
-    private get identifierTypeDeclarations();
-    private get isTypeFunctionDeclaration();
-    private get schemaVariableStatement();
-    private get toRdfResourceFunctionDeclaration();
-    graphqlResolveExpression({ variables, }: {
-        variables: {
-            value: Code;
-        };
-    }): Code;
-}
-//# sourceMappingURL=NamedObjectUnionType.d.ts.map

package/dist/generators/ts/NamedUnionType.d.ts

@@ -1,11 +0,0 @@
-import { AbstractNamedUnionType } from "./AbstractNamedUnionType.js";
-import type { AbstractType } from "./AbstractType.js";
-import type { Type } from "./Type.js";
-import type { Code } from "./ts-poet-wrapper.js";
-export declare class NamedUnionType extends AbstractNamedUnionType<Type> {
-    readonly graphqlArgs: AbstractType["graphqlArgs"];
-    readonly kind = "NamedUnion";
-    graphqlResolveExpression(): Code;
-    get graphqlType(): AbstractType.GraphqlType;
-}
-//# sourceMappingURL=NamedUnionType.d.ts.map