@shaclmate/compiler 4.0.49 → 4.0.50

package/dist/generators/ts/ObjectType.js

@@ -1,492 +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 { 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 { 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 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, "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

@@ -1,20 +0,0 @@
-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