@shaclmate/compiler 4.0.50 → 4.0.51

package/dist/generators/ts/ObjectType.js

@@ -0,0 +1,503 @@
+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 { invariant } from "ts-invariant";
+import { Memoize } from "typescript-memoize";
+import { DiscriminantProperty as _DiscriminantProperty } from "./_ObjectType/DiscriminantProperty.js";
+import { IdentifierProperty as _IdentifierProperty } from "./_ObjectType/IdentifierProperty.js";
+import { ObjectType_createFunctionExpression } from "./_ObjectType/ObjectType_createFunctionExpression.js";
+import { ObjectType_equalsFunctionExpression } from "./_ObjectType/ObjectType_equalsFunctionExpression.js";
+import { ObjectType_filterFunctionExpression } from "./_ObjectType/ObjectType_filterFunctionExpression.js";
+import { ObjectType_filterTypeExpression } from "./_ObjectType/ObjectType_filterTypeExpression.js";
+import { ObjectType_focusSparqlConstructTriplesFunctionExpression } from "./_ObjectType/ObjectType_focusSparqlConstructTriplesFunctionExpression.js";
+import { ObjectType_focusSparqlWherePatternsFunctionExpression } from "./_ObjectType/ObjectType_focusSparqlWherePatternsFunctionExpression.js";
+import { ObjectType_fromJsonFunctionExpression } from "./_ObjectType/ObjectType_fromJsonFunctionExpression.js";
+import { ObjectType_fromRdfResourceFunctionExpression } from "./_ObjectType/ObjectType_fromRdfResourceFunctionExpression.js";
+import { ObjectType_graphqlTypeExpression } from "./_ObjectType/ObjectType_graphqlTypeExpression.js";
+import { ObjectType_hashFunctionExpression } from "./_ObjectType/ObjectType_hashFunctionExpression.js";
+import { ObjectType_identifierTypeDeclarations } from "./_ObjectType/ObjectType_identifierTypeDeclarations.js";
+import { ObjectType_isTypeFunctionDeclaration } from "./_ObjectType/ObjectType_isTypeFunctionDeclaration.js";
+import { ObjectType_jsonParseFunctionDeclaration } from "./_ObjectType/ObjectType_jsonParseFunctionDeclaration.js";
+import { ObjectType_jsonSchemaExpression } from "./_ObjectType/ObjectType_jsonSchemaExpression.js";
+import { ObjectType_jsonTypeExpression } from "./_ObjectType/ObjectType_jsonTypeExpression.js";
+import { ObjectType_jsonUiSchemaFunctionExpression } from "./_ObjectType/ObjectType_jsonUiSchemaFunctionExpression.js";
+import { ObjectType_objectSetMethodNames } from "./_ObjectType/ObjectType_objectSetMethodNames.js";
+import { ObjectType_schemaExpression } from "./_ObjectType/ObjectType_schemaExpression.js";
+import { ObjectType_schemaTypeExpression } from "./_ObjectType/ObjectType_schemaTypeExpression.js";
+import { ObjectType_sparqlConstructQueryFunctionDeclaration } from "./_ObjectType/ObjectType_sparqlConstructQueryFunctionDeclaration.js";
+import { ObjectType_sparqlConstructQueryStringFunctionDeclaration } from "./_ObjectType/ObjectType_sparqlConstructQueryStringFunctionDeclaration.js";
+import { ObjectType_toJsonFunctionExpression } from "./_ObjectType/ObjectType_toJsonFunctionExpression.js";
+import { ObjectType_toRdfResourceFunctionExpression } from "./_ObjectType/ObjectType_toRdfResourceFunctionExpression.js";
+import { ObjectType_toStringFunctionExpression } from "./_ObjectType/ObjectType_toStringFunctionExpression.js";
+import { ObjectType_toStringRecordFunctionExpression } from "./_ObjectType/ObjectType_toStringRecordFunctionExpression.js";
+import { ObjectType_valueSparqlConstructTriplesFunctionExpression } from "./_ObjectType/ObjectType_valueSparqlConstructTriplesFunctionExpression.js";
+import { ObjectType_valueSparqlWherePatternsFunctionExpression } from "./_ObjectType/ObjectType_valueSparqlWherePatternsFunctionExpression.js";
+import { ShaclProperty as _ShaclProperty } from "./_ObjectType/ShaclProperty.js";
+import { AbstractType } from "./AbstractType.js";
+import { arrayOf, code, def, joinCode } from "./ts-poet-wrapper.js";
+import { tsComment } from "./tsComment.js";
+export class ObjectType extends AbstractType {
+    toRdfTypes;
+    discriminantProperty;
+    extern;
+    fromRdfType;
+    graphqlArgs = Maybe.empty();
+    identifierType;
+    jsTypes = [
+        { instanceof: "Object", typeof: "object" },
+    ];
+    kind = "Object";
+    recursive;
+    synthetic;
+    validationFunction = Maybe.empty();
+    constructor({ discriminantProperty, extern, fromRdfType, identifierType, lazyProperties, recursive, synthetic, toRdfTypes, ...superParameters }) {
+        super(superParameters);
+        this.discriminantProperty = discriminantProperty;
+        this.extern = extern;
+        this.fromRdfType = fromRdfType;
+        this.identifierType = identifierType;
+        // Lazily initialize some members in getters to avoid recursive construction
+        this.lazyProperties = lazyProperties;
+        this.recursive = recursive;
+        this.synthetic = synthetic;
+        this.toRdfTypes = toRdfTypes;
+    }
+    get conversionFunction() {
+        if (this.name.isJust()) {
+            return Maybe.empty();
+        }
+        return Maybe.of({
+            code: this.createFunction,
+            sourceTypes: [
+                {
+                    expression: this.constructorParameters.type.expression,
+                    jsType: {
+                        instanceof: "Object",
+                        typeof: "object",
+                    },
+                },
+            ],
+        });
+    }
+    get declaration() {
+        const name = this.name.extract();
+        if (!name) {
+            return Maybe.empty();
+        }
+        const declarations = [];
+        if (!this.extern) {
+            if (this.configuration.features.has("Object.type")) {
+                declarations.push(code `\
+ ${this.comment
+                    .alt(this.label)
+                    .map(tsComment)
+                    .orDefault("")}export type ${name} = ${this.inlineExpression};`);
+            }
+            let staticModuleDeclarations = [];
+            // create
+            if (this.configuration.features.has("Object.create")) {
+                staticModuleDeclarations.push(code `export const create: (${this.constructorParameters.signature}) => ${this.reusables.imports.Either}<Error, ${this.expression}> = ${ObjectType_createFunctionExpression.call(this)};`, code `export function createUnsafe(${this.constructorParameters.signature}): ${this.expression} {
+  return create(parameters).unsafeCoerce();
+}`);
+            }
+            // equals
+            if (this.configuration.features.has("Object.equals")) {
+                staticModuleDeclarations.push(code `export const equals: (left: ${this.expression}, right: ${this.expression}) => ${this.reusables.snippets.EqualsResult} = ${ObjectType_equalsFunctionExpression.call(this)};`);
+            }
+            // Filter / filter
+            if (this.configuration.features.has("Object.filter")) {
+                staticModuleDeclarations.push(code `export type Filter = ${ObjectType_filterTypeExpression.call(this)};`);
+                staticModuleDeclarations.push(code `export const filter: (filter: ${this.filterType}, value: ${this.expression}) => boolean = ${ObjectType_filterFunctionExpression.call(this)};`);
+            }
+            // GraphQL
+            if (this.configuration.features.has("GraphQL") && !this.synthetic) {
+                staticModuleDeclarations.push(code `export const GraphQL = ${ObjectType_graphqlTypeExpression.call(this)};`);
+            }
+            // focusSparqlConstructTriples / focusSparqlWherePatterns
+            if (this.configuration.features.has("Object.SPARQL")) {
+                staticModuleDeclarations.push(code `export const focusSparqlConstructTriples: ${this.reusables.snippets.FocusSparqlConstructTriplesFunction}<${this.filterType}> = ${ObjectType_focusSparqlConstructTriplesFunctionExpression.call(this)};`, code `export const focusSparqlWherePatterns: ${this.reusables.snippets.FocusSparqlWherePatternsFunction}<${this.filterType}> = ${ObjectType_focusSparqlWherePatternsFunctionExpression.call(this)};`);
+            }
+            // fromJson
+            if (this.configuration.features.has("Object.fromJson")) {
+                staticModuleDeclarations.push(code `export const fromJson: (json: ${this.jsonType().expression}) => ${this.reusables.imports.Either}<Error, ${this.expression}> = ${ObjectType_fromJsonFunctionExpression.call(this)};`);
+            }
+            // fromRdfResource / fromRdfResourceValues
+            if (this.configuration.features.has("Object.fromRdf")) {
+                staticModuleDeclarations.push(code `export const _fromRdfResource: ${this.reusables.snippets._FromRdfResourceFunction}<${this.expression}> = ${ObjectType_fromRdfResourceFunctionExpression.call(this)};`, code `export const fromRdfResource = ${this.reusables.snippets.wrap_FromRdfResourceFunction}(_fromRdfResource);`, code `export const fromRdfResourceValues: ${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.expression}, ${this.schemaType}> = 
+  (values, options) => values.chainMap(value => value.toResource().chain(resource => fromRdfResource(resource, options)));`);
+            }
+            // hash
+            if (this.configuration.features.has("Object.hash")) {
+                staticModuleDeclarations.push(code `export const hash = ${ObjectType_hashFunctionExpression.call(this)};`);
+            }
+            // Identifier
+            if (this.configuration.features.has("Object.type")) {
+                staticModuleDeclarations = staticModuleDeclarations.concat(ObjectType_identifierTypeDeclarations.call(this));
+            }
+            // isType
+            staticModuleDeclarations = staticModuleDeclarations.concat(ObjectType_isTypeFunctionDeclaration.call(this).toList());
+            // type Json
+            if (this.configuration.features.has("Object.JSON.type")) {
+                staticModuleDeclarations.push(code `export type Json = ${ObjectType_jsonTypeExpression.call(this)}`);
+            }
+            // namespace Json
+            {
+                const jsonModuleDeclarations = [];
+                if (this.configuration.features.has("Object.JSON.parse")) {
+                    jsonModuleDeclarations.push(ObjectType_jsonParseFunctionDeclaration.call(this));
+                }
+                if (this.configuration.features.has("Object.JSON.schema")) {
+                    jsonModuleDeclarations.push(code `export function schema() { return ${ObjectType_jsonSchemaExpression.call(this)} satisfies ${this.reusables.imports.z}.ZodType<Json>; }`);
+                }
+                if (this.configuration.features.has("Object.JSON.uiSchema")) {
+                    jsonModuleDeclarations.push(code `export const uiSchema = ${ObjectType_jsonUiSchemaFunctionExpression.call(this)};`);
+                }
+                if (jsonModuleDeclarations.length > 0) {
+                    staticModuleDeclarations.push(code `export namespace Json { ${joinCode(jsonModuleDeclarations, { on: "\n\n" })} }`);
+                }
+            }
+            // schema / Schema
+            if (this.configuration.features.has("Object.schema")) {
+                staticModuleDeclarations.push(code `export const schema = ${ObjectType_schemaExpression.call(this)};`, code `export type Schema = typeof schema;`);
+            }
+            // sparqlConstructQuery / sparqlConstructQueryString
+            if (this.configuration.features.has("Object.SPARQL")) {
+                staticModuleDeclarations.push(ObjectType_sparqlConstructQueryFunctionDeclaration.call({
+                    name,
+                    configuration: this.configuration,
+                    filterType: this.filterType,
+                    reusables: this.reusables,
+                }), ObjectType_sparqlConstructQueryStringFunctionDeclaration.call({
+                    name,
+                    configuration: this.configuration,
+                    filterType: this.filterType,
+                    reusables: this.reusables,
+                }));
+            }
+            // toJson
+            if (this.configuration.features.has("Object.toJson")) {
+                staticModuleDeclarations.push(code `export const toJson: (${this.thisVariable}: ${this.expression}) => ${this.jsonType().expression} = ${ObjectType_toJsonFunctionExpression.call(this)};`);
+            }
+            // toRdfResource
+            if (this.configuration.features.has("Object.toRdf")) {
+                staticModuleDeclarations.push(code `export const _toRdfResource: ${this.reusables.snippets._ToRdfResourceFunction}<${this.identifierTypeAlias}, ${this.expression}> = ${ObjectType_toRdfResourceFunctionExpression.call(this)};`, code `export const toRdfResource = ${this.reusables.snippets.wrap_ToRdfResourceFunction}(_toRdfResource);`);
+            }
+            // toString / toStringRecord
+            if (this.configuration.features.has("Object.toString")) {
+                staticModuleDeclarations.push(code `export const ${this.configuration.syntheticNamePrefix}toString: (${this.thisVariable}: ${this.expression}) => string = ${ObjectType_toStringFunctionExpression.call(this)};`, code `export const toStringRecord: (${this.thisVariable}: ${this.expression}) => Record<string, string> = ${ObjectType_toStringRecordFunctionExpression.call(this)};`);
+            }
+            // valueSparqlConstructTriples / valueSparqlWherePatterns
+            if (this.configuration.features.has("Object.SPARQL")) {
+                staticModuleDeclarations.push(code `export const valueSparqlConstructTriples: ${this.reusables.snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}> = ${ObjectType_valueSparqlConstructTriplesFunctionExpression.call(this)};`, code `export const valueSparqlWherePatterns: ${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}> = ${ObjectType_valueSparqlWherePatternsFunctionExpression.call(this)};`);
+            }
+            if (staticModuleDeclarations.length > 0) {
+                declarations.push(code `\
+export namespace ${def(name)} {
+${joinCode(staticModuleDeclarations, { on: "\n\n" })}
+}`);
+            }
+        }
+        if (declarations.length === 0) {
+            return Maybe.empty();
+        }
+        return Maybe.of(joinCode(declarations, { on: "\n\n" }));
+    }
+    get equalsFunction() {
+        return this.name
+            .map((name) => code `${name}.equals`)
+            .orDefaultLazy(() => ObjectType_equalsFunctionExpression.call(this));
+    }
+    get expression() {
+        return this.name
+            .map((name) => code `${name}`)
+            .orDefaultLazy(() => this.inlineExpression);
+    }
+    get filterFunction() {
+        return this.name
+            .map((name) => code `${name}.filter`)
+            .orDefaultLazy(() => ObjectType_filterFunctionExpression.call(this));
+    }
+    get filterType() {
+        return this.name
+            .map((name) => code `${name}.Filter`)
+            .orDefaultLazy(() => ObjectType_filterTypeExpression.call(this));
+    }
+    get fromRdfResourceValuesFunction() {
+        return this.name
+            .map((name) => code `${name}.fromRdfResourceValues`)
+            .orDefaultLazy(() => code `((values, options) => values.chainMap(value => value.toResource().chain(resource => ${ObjectType_fromRdfResourceFunctionExpression.call(this)}(resource, options))))`);
+    }
+    get fromRdfTypeVariable() {
+        return this.fromRdfType.map((fromRdfType) => this.name
+            .map((name) => code `${name}.schema.fromRdfType`)
+            .orDefaultLazy(() => this.rdfjsTermExpression(fromRdfType)));
+    }
+    get graphqlType() {
+        return new AbstractType.GraphqlType(this.name
+            .map((name) => code `${name}.GraphQL`)
+            .orDefaultLazy(() => ObjectType_graphqlTypeExpression.call(this)), this.reusables);
+    }
+    get hashFunction() {
+        return this.name
+            .map((name) => code `${name}.hash`)
+            .orDefaultLazy(() => ObjectType_hashFunctionExpression.call(this));
+    }
+    get identifierTypeAlias() {
+        return code `${this.name.unsafeCoerce()}.Identifier`;
+    }
+    get mutable() {
+        return this.properties.some((property) => property.mutable);
+    }
+    get objectSetMethodNames() {
+        return ObjectType_objectSetMethodNames.call({
+            name: this.name.unsafeCoerce(),
+            configuration: this.configuration,
+        });
+    }
+    get properties() {
+        const properties = this.lazyProperties(this);
+        invariant(properties.length > 0, `${this.name.extract()}: empty properties`);
+        return properties;
+    }
+    get referencesNamedType() {
+        return (this.name.isJust() ||
+            this.properties.some((property) => {
+                switch (property.kind) {
+                    case "Identifier":
+                    case "Shacl":
+                        return property.type.referencesNamedType;
+                    default:
+                        return false;
+                }
+            }));
+    }
+    get schema() {
+        return this.name
+            .map((name) => code `${name}.schema`)
+            .orDefaultLazy(() => ObjectType_schemaExpression.call(this));
+    }
+    get schemaType() {
+        return this.name
+            .map((name) => code `${name}.Schema`)
+            .orDefaultLazy(() => ObjectType_schemaTypeExpression.call(this));
+    }
+    get toRdfResourceValueTypes() {
+        return new Set([...this.identifierType.nodeKinds].map(NodeKind.toTermType));
+    }
+    get toRdfjsResourceType() {
+        return code `${this.reusables.imports.Resource}${this.identifierType.kind === "Iri" ? code `<${this.reusables.imports.NamedNode}>` : ""}`;
+    }
+    get valueSparqlConstructTriplesFunction() {
+        return this.name
+            .map((name) => code `${name}.valueSparqlConstructTriples`)
+            .orDefaultLazy(() => ObjectType_valueSparqlConstructTriplesFunctionExpression.call(this));
+    }
+    get valueSparqlWherePatternsFunction() {
+        return this.name
+            .map((name) => code `${name}.valueSparqlWherePatterns`)
+            .orDefaultLazy(() => ObjectType_valueSparqlWherePatternsFunctionExpression.call(this));
+    }
+    get constructorParameters() {
+        let hasQuestionToken = true;
+        const propertySignatures = [];
+        for (const property of this.properties) {
+            property.constructorParameter.ifJust((propertyConstructorParameter) => {
+                hasQuestionToken =
+                    hasQuestionToken && propertyConstructorParameter.hasQuestionToken;
+                propertySignatures.push(propertyConstructorParameter.signature);
+            });
+        }
+        invariant(propertySignatures.length > 0);
+        const typeExpression = code `{ ${joinCode(propertySignatures)} }`;
+        return {
+            hasQuestionToken,
+            signature: code `parameters${hasQuestionToken ? "?" : ""}: ${typeExpression}`,
+            type: {
+                expression: typeExpression,
+            },
+            variable: "parameters",
+        };
+    }
+    get createFunction() {
+        return this.name
+            .map((name) => code `${name}.create`)
+            .orDefaultLazy(() => ObjectType_createFunctionExpression.call(this));
+    }
+    get thisVariable() {
+        return this.name
+            .map((name) => code `_${camelCase(name)}`)
+            .orDefault(code `_object`);
+    }
+    get toJsonFunction() {
+        return this.name
+            .map((name) => code `${name}.toJson`)
+            .orDefaultLazy(() => ObjectType_toJsonFunctionExpression.call(this));
+    }
+    get toRdfTypesVariable() {
+        if (this.toRdfTypes.length === 0) {
+            return Maybe.empty();
+        }
+        return Maybe.of(this.name
+            .map((name) => code `${name}.schema.toRdfTypes`)
+            .orDefaultLazy(() => code `${arrayOf(...this.toRdfTypes.map((toRdfType) => this.rdfjsTermExpression(toRdfType)))}`));
+    }
+    get toStringFunction() {
+        return this.name
+            .map((name) => code `${name}.${this.configuration.syntheticNamePrefix}toString`)
+            .orDefaultLazy(() => ObjectType_toStringFunctionExpression.call(this));
+    }
+    get inlineExpression() {
+        return code `{ ${joinCode(this.properties.map((property) => property.declaration), { on: "\n\n" })} }`;
+    }
+    fromJsonExpression({ variables, }) {
+        // Assumes the JSON object has been recursively validated already.
+        return code `${this.name.map((name) => code `${name}.fromJson`).orDefaultLazy(() => ObjectType_fromJsonFunctionExpression.call(this))}(${variables.value})`;
+    }
+    graphqlResolveExpression({ variables, }) {
+        return variables.value;
+    }
+    jsonSchema({ context, }) {
+        return this.name
+            .map((name) => {
+            let expression = code `${name}.Json.schema()`;
+            if (context === "property" &&
+                this.properties.some((property) => property.recursive)) {
+                expression = code `${this.reusables.imports.z}.lazy((): ${this.reusables.imports.z}.ZodType<${name}.Json> => ${expression})`;
+            }
+            return expression;
+        })
+            .orDefaultLazy(() => ObjectType_jsonSchemaExpression.call(this));
+    }
+    jsonType() {
+        return new AbstractType.JsonType(this.name
+            .map((name) => code `${name}.Json`)
+            .orDefaultLazy(() => ObjectType_jsonTypeExpression.call(this)));
+    }
+    jsonUiSchemaElement({ variables, }) {
+        return Maybe.of(code `${this.name
+            .map((name) => code `${name}.Json.uiSchema`)
+            .orDefaultLazy(() => ObjectType_jsonUiSchemaFunctionExpression.call(this))}({ scopePrefix: ${variables.scopePrefix} })`);
+    }
+    toJsonExpression({ variables, }) {
+        const toJsonFunction = this.name
+            .map((name) => code `${name}.toJson`)
+            .orDefaultLazy(() => ObjectType_toJsonFunctionExpression.call(this));
+        return code `${toJsonFunction}(${variables.value})`;
+    }
+    toRdfResourceValuesExpression({ variables, }) {
+        const toRdfResourceFunction = this.name
+            .map((name) => code `${name}.toRdfResource`)
+            .orDefaultLazy(() => code `${this.reusables.snippets.wrap_ToRdfResourceFunction}<${this.identifierType.expression}, ${this.expression}>(${ObjectType_toRdfResourceFunctionExpression.call(this)})`);
+        return code `[${toRdfResourceFunction}(${variables.value}, { graph: ${variables.graph}, resourceSet: ${variables.resourceSet} }).identifier]`;
+    }
+    toStringExpression({ variables, }) {
+        return this.name
+            .map((name) => code `${name}.${this.configuration.syntheticNamePrefix}toString(${variables.value})`)
+            .orDefaultLazy(() => code `JSON.stringify(${this.toStringRecordExpression({ variables })})`);
+    }
+    toStringRecordExpression({ variables, }) {
+        return code `${this.reusables.snippets.compactRecord}({${joinCode(this.properties.flatMap((property) => property
+            .toStringInitializer({
+            variables: {
+                value: property.accessExpression({
+                    variables: { object: variables.value },
+                }),
+            },
+        })
+            .toList()), { on: "," })}})`;
+    }
+    lazyProperties;
+}
+__decorate([
+    Memoize()
+], ObjectType.prototype, "conversionFunction", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "equalsFunction", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "expression", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "filterFunction", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "filterType", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "fromRdfResourceValuesFunction", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "fromRdfTypeVariable", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "graphqlType", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "hashFunction", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "identifierTypeAlias", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "mutable", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "objectSetMethodNames", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "properties", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "referencesNamedType", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "schema", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "schemaType", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "toRdfResourceValueTypes", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "toRdfjsResourceType", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "valueSparqlConstructTriplesFunction", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "valueSparqlWherePatternsFunction", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "constructorParameters", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "createFunction", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "thisVariable", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "toJsonFunction", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "toRdfTypesVariable", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "toStringFunction", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "jsonType", null);
+(function (ObjectType) {
+    ObjectType.IdentifierProperty = _IdentifierProperty;
+    ObjectType.ShaclProperty = _ShaclProperty;
+    ObjectType.DiscriminantProperty = _DiscriminantProperty;
+})(ObjectType || (ObjectType = {}));
+//# sourceMappingURL=ObjectType.js.map

package/dist/generators/ts/ObjectUnionType.d.ts

@@ -0,0 +1,20 @@
+import type { ObjectType } from "./ObjectType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+import { UnionType } from "./UnionType.js";
+export declare class ObjectUnionType extends UnionType<ObjectType> {
+    readonly kind = "ObjectUnion";
+    get identifierTypeAlias(): Code;
+    get objectSetMethodNames(): ObjectType.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();
+}
+//# sourceMappingURL=ObjectUnionType.d.ts.map