@shaclmate/compiler 2.0.20 → 2.0.23

package/dist/generators/ts/ObjectType.js

@@ -9,41 +9,45 @@ import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { StructureKind, } from "ts-morph";
 import { Memoize } from "typescript-memoize";
+import * as _ObjectType from "./_ObjectType/index.js";
 import { DeclaredType } from "./DeclaredType.js";
 import { Import } from "./Import.js";
 import { SnippetDeclarations } from "./SnippetDeclarations.js";
-import * as _ObjectType from "./_ObjectType/index.js";
+import { Type } from "./Type.js";
 import { objectInitializer } from "./objectInitializer.js";
+import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 export class ObjectType extends DeclaredType {
+    imports;
+    comment;
+    identifierMintingStrategy;
+    label;
+    toRdfTypes;
     abstract;
     declarationType;
-    kind = "ObjectType";
-    comment;
     extern;
     fromRdfType;
-    label;
-    identifierMintingStrategy;
-    toRdfTypes;
-    imports;
-    lazyAncestorObjectTypes;
-    lazyDescendantObjectTypes;
-    lazyParentObjectTypes;
-    lazyProperties;
-    constructor({ abstract, comment, declarationType, extern, fromRdfType, label, lazyAncestorObjectTypes, lazyDescendantObjectTypes, lazyParentObjectTypes, lazyProperties, imports, identifierMintingStrategy, toRdfTypes, ...superParameters }) {
+    kind = "ObjectType";
+    staticModuleName;
+    synthetic;
+    typeof = "object";
+    constructor({ abstract, comment, declarationType, extern, fromRdfType, imports, identifierMintingStrategy, label, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyParentObjectTypes, lazyProperties, staticModuleName, synthetic, toRdfTypes, ...superParameters }) {
         super(superParameters);
         this.abstract = abstract;
         this.comment = comment;
         this.declarationType = declarationType;
         this.extern = extern;
         this.fromRdfType = fromRdfType;
+        this.identifierMintingStrategy = identifierMintingStrategy;
         this.imports = imports;
         this.label = label;
         // Lazily initialize some members in getters to avoid recursive construction
         this.lazyAncestorObjectTypes = lazyAncestorObjectTypes;
+        this.lazyChildObjectTypes = lazyChildObjectTypes;
         this.lazyDescendantObjectTypes = lazyDescendantObjectTypes;
         this.lazyParentObjectTypes = lazyParentObjectTypes;
         this.lazyProperties = lazyProperties;
-        this.identifierMintingStrategy = identifierMintingStrategy;
+        this.staticModuleName = staticModuleName;
+        this.synthetic = synthetic;
         this.toRdfTypes = toRdfTypes;
     }
     get _discriminatorProperty() {
@@ -51,12 +55,16 @@ export class ObjectType extends DeclaredType {
         invariant(discriminatorProperty);
         return {
             name: discriminatorProperty.name,
-            values: [this.discriminatorValue],
+            ownValues: discriminatorProperty.type.ownValues,
+            descendantValues: discriminatorProperty.type.descendantValues,
         };
     }
     get ancestorObjectTypes() {
         return this.lazyAncestorObjectTypes();
     }
+    get childObjectTypes() {
+        return this.lazyChildObjectTypes();
+    }
     get conversions() {
         return [
             {
@@ -71,13 +79,15 @@ export class ObjectType extends DeclaredType {
             return [];
         }
         const imports = this.properties.flatMap((property) => property.declarationImports);
-        if (this.features.has("fromJson") || this.features.has("jsonSchema")) {
-            imports.push(Import.ZOD);
+        if (this.features.has("graphql")) {
+            imports.push(Import.GRAPHQL);
+            imports.push(Import.GRAPHQL_SCALARS);
         }
-        if (this.features.has("jsonSchema")) {
+        if (this.features.has("json")) {
+            imports.push(Import.ZOD);
             imports.push(Import.ZOD_TO_JSON_SCHEMA);
         }
-        if (this.features.has("fromRdf") || this.features.has("toRdf")) {
+        if (this.features.has("rdf")) {
             imports.push(Import.PURIFY);
             imports.push(Import.RDFJS_RESOURCE);
         }
@@ -91,26 +101,25 @@ export class ObjectType extends DeclaredType {
             ..._ObjectType.classDeclaration.bind(this)().toList(),
             ..._ObjectType.interfaceDeclaration.bind(this)().toList(),
         ];
-        const moduleStatements = [
+        const staticModuleStatements = [
             ..._ObjectType.createFunctionDeclaration.bind(this)().toList(),
             ..._ObjectType.equalsFunctionDeclaration.bind(this)().toList(),
-            ..._ObjectType.fromJsonFunctionDeclarations.bind(this)(),
-            ..._ObjectType.fromRdfFunctionDeclarations.bind(this)(),
-            ..._ObjectType.fromRdfTypeVariableDeclaration.bind(this)().toList(),
-            ..._ObjectType.jsonSchemaFunctionDeclaration.bind(this)().toList(),
-            ..._ObjectType.jsonUiSchemaFunctionDeclaration.bind(this)().toList(),
-            ..._ObjectType.jsonZodSchemaFunctionDeclaration.bind(this)().toList(),
+            ..._ObjectType.fromRdfTypeVariableStatement.bind(this)().toList(),
+            ..._ObjectType.graphqlTypeVariableStatement.bind(this)().toList(),
+            ..._ObjectType.identifierTypeDeclarations.bind(this)(),
+            ..._ObjectType.jsonTypeAliasDeclaration.bind(this)().toList(),
+            ..._ObjectType.jsonFunctionDeclarations.bind(this)(),
             ..._ObjectType.hashFunctionDeclarations.bind(this)(),
+            ..._ObjectType.rdfFunctionDeclarations.bind(this)(),
+            ..._ObjectType.propertiesVariableStatement.bind(this)().toList(),
             ..._ObjectType.sparqlFunctionDeclarations.bind(this)(),
-            ..._ObjectType.toJsonFunctionDeclaration.bind(this)().toList(),
-            ..._ObjectType.toRdfFunctionDeclaration.bind(this)().toList(),
         ];
-        if (moduleStatements.length > 0) {
+        if (staticModuleStatements.length > 0) {
             declarations.push({
                 isExported: this.export,
                 kind: StructureKind.Module,
-                name: this.name,
-                statements: moduleStatements,
+                name: this.staticModuleName,
+                statements: staticModuleStatements,
             });
         }
         return declarations;
@@ -127,24 +136,18 @@ export class ObjectType extends DeclaredType {
     get equalsFunction() {
         switch (this.declarationType) {
             case "class":
-                return "((left, right) => left.equals(right))";
+                return `((left, right) => left.${syntheticNamePrefix}equals(right))`;
             case "interface":
-                return `${this.name}.equals`;
+                return `${this.staticModuleName}.${syntheticNamePrefix}equals`;
             default:
                 throw new RangeError(this.declarationType);
         }
     }
-    get hashFunctionName() {
-        if (this.ancestorObjectTypes.length > 0 ||
-            this.descendantObjectTypes.length > 0)
-            return `hash${this.name}`;
-        return "hash";
+    get fromRdfTypeVariable() {
+        return this.fromRdfType.map(() => `${this.staticModuleName}.${syntheticNamePrefix}fromRdfType`);
     }
-    get hashShaclPropertiesFunctionName() {
-        if (this.ancestorObjectTypes.length > 0 ||
-            this.descendantObjectTypes.length > 0)
-            return `_hash${this.name}ShaclProperties`;
-        return "_hashShaclProperties";
+    get graphqlName() {
+        return new Type.GraphqlName(`${this.staticModuleName}.${syntheticNamePrefix}GraphQL`);
     }
     get identifierProperty() {
         const identifierProperty = this.properties.find((property) => property instanceof ObjectType.IdentifierProperty);
@@ -154,37 +157,26 @@ export class ObjectType extends DeclaredType {
     get identifierType() {
         return this.identifierProperty.type;
     }
-    get jsonName() {
-        if (this.features.has("toJson")) {
-            switch (this.declarationType) {
-                case "class":
-                    return `ReturnType<${this.name}["toJson"]>`;
-                case "interface":
-                    return `ReturnType<typeof ${this.name}.toJson>`;
-                default:
-                    throw new RangeError(this.declarationType);
-            }
-        }
-        if (this.features.has("fromJson")) {
-            return `Parameters<typeof ${this.name}.fromJson>[0]`;
-        }
-        throw new RangeError(`${this.name}: jsonName called when neither fromJson nor toJson features are enabled`);
-    }
-    get jsonUiSchemaFunctionName() {
-        if (this.ancestorObjectTypes.length > 0 ||
-            this.descendantObjectTypes.length > 0)
-            return `${camelCase(this.name)}JsonUiSchema`;
-        return "jsonUiSchema";
+    get identifierTypeAlias() {
+        return `${this.staticModuleName}.${syntheticNamePrefix}Identifier`;
     }
-    get jsonZodSchemaFunctionName() {
-        if (this.ancestorObjectTypes.length > 0 ||
-            this.descendantObjectTypes.length > 0)
-            return `${camelCase(this.name)}JsonZodSchema`;
-        return "jsonZodSchema";
+    get jsonName() {
+        return new Type.JsonName(`${this.staticModuleName}.${syntheticNamePrefix}Json`);
     }
     get mutable() {
         return this.properties.some((property) => property.mutable);
     }
+    newExpression({ parameters }) {
+        switch (this.declarationType) {
+            case "class":
+                return `new ${this.name}(${parameters})`;
+            case "interface":
+                return `${this.staticModuleName}.create(${parameters})`;
+        }
+    }
+    get objectSetMethodNames() {
+        return _ObjectType.objectSetMethodNames.bind(this)();
+    }
     get ownProperties() {
         if (this.parentObjectTypes.length === 0) {
             // Consider that a root of the object type hierarchy "owns" the identifier and type discriminator properties
@@ -201,7 +193,7 @@ export class ObjectType extends DeclaredType {
         return this.lazyParentObjectTypes();
     }
     get properties() {
-        const properties = this.lazyProperties();
+        const properties = this.lazyProperties(this);
         const propertyNames = new Set();
         for (const property of properties) {
             if (propertyNames.has(property.name)) {
@@ -210,6 +202,12 @@ export class ObjectType extends DeclaredType {
         }
         return properties;
     }
+    get toRdfjsResourceType() {
+        if (this.parentObjectTypes.length > 0) {
+            return this.parentObjectTypes[0].toRdfjsResourceType;
+        }
+        return `rdfjsResource.MutableResource${this.identifierType.isNamedNodeKind ? "<rdfjs.NamedNode>" : ""}`;
+    }
     get thisVariable() {
         switch (this.declarationType) {
             case "class":
@@ -222,79 +220,89 @@ export class ObjectType extends DeclaredType {
     }
     fromJsonExpression({ variables, }) {
         // Assumes the JSON object has been recursively validated already.
-        return `${this.name}.fromJson(${variables.value}).unsafeCoerce()`;
+        return `${this.staticModuleName}.${syntheticNamePrefix}fromJson(${variables.value}).unsafeCoerce()`;
     }
     fromRdfExpression({ variables, }) {
-        // Ignore the rdf:type if the instance of this type is the object of another property.
-        // Instead, assume the property has the correct range.
-        // This also accommodates the case where the object of a property is a dangling identifier that's not the
-        // subject of any statements.
-        return `${variables.resourceValues}.head().chain(value => value.to${this.rdfjsResourceType().named ? "Named" : ""}Resource()).chain(_resource => ${this.name}.fromRdf({ ...${variables.context}, ignoreRdfType: true, languageIn: ${variables.languageIn}, resource: _resource }))`;
+        return `${variables.resourceValues}.head().chain(value => value.toResource()).chain(_resource => ${this.staticModuleName}.${syntheticNamePrefix}fromRdf({ ...${variables.context}, ${variables.ignoreRdfType ? "ignoreRdfType: true, " : ""}languageIn: ${variables.languageIn}, objectSet: ${variables.objectSet}, resource: _resource }))`;
+    }
+    graphqlResolveExpression({ variables, }) {
+        return variables.value;
     }
     hashStatements({ variables, }) {
         switch (this.declarationType) {
             case "class":
-                return [`${variables.value}.hash(${variables.hasher});`];
+                return [
+                    `${variables.value}.${syntheticNamePrefix}hash(${variables.hasher});`,
+                ];
             case "interface":
                 return [
-                    `${this.name}.${this.hashFunctionName}(${variables.value}, ${variables.hasher});`,
+                    `${this.staticModuleName}.${syntheticNamePrefix}hash(${variables.value}, ${variables.hasher});`,
                 ];
         }
     }
     jsonUiSchemaElement({ variables, }) {
-        return Maybe.of(`${this.name}.${this.jsonUiSchemaFunctionName}({ scopePrefix: ${variables.scopePrefix} })`);
-    }
-    jsonZodSchema(_parameters) {
-        return `${this.name}.${this.jsonZodSchemaFunctionName}()`;
+        return Maybe.of(`${this.staticModuleName}.${syntheticNamePrefix}jsonUiSchema({ scopePrefix: ${variables.scopePrefix} })`);
     }
-    rdfjsResourceType(options) {
-        if (this.parentObjectTypes.length > 0) {
-            return this.parentObjectTypes[0].rdfjsResourceType(options);
+    jsonZodSchema({ context, variables, }) {
+        let expression = `${this.staticModuleName}.${syntheticNamePrefix}jsonZodSchema()`;
+        if (context === "property" &&
+            this.properties.some((property) => property.recursive)) {
+            expression = `${variables.zod}.lazy((): ${variables.zod}.ZodType<${this.staticModuleName}.${syntheticNamePrefix}Json> => ${expression})`;
         }
-        return {
-            mutable: !!options?.mutable,
-            name: `rdfjsResource.${options?.mutable ? "Mutable" : ""}Resource${this.identifierType.isNamedNodeKind ? "<rdfjs.NamedNode>" : ""}`,
-            named: this.identifierType.isNamedNodeKind,
-        };
+        return expression;
     }
-    snippetDeclarations() {
+    snippetDeclarations({ recursionStack, }) {
+        if (recursionStack.some((type) => Object.is(type, this))) {
+            return [];
+        }
         const snippetDeclarations = [];
         if (this.features.has("equals")) {
             snippetDeclarations.push(SnippetDeclarations.EqualsResult);
         }
-        if ((this.features.has("fromJson") || this.features.has("fromRdf")) &&
+        if (this.features.has("rdf")) {
+            snippetDeclarations.push(SnippetDeclarations.RdfVocabularies);
+        }
+        if (this.features.has("sparql") && this.fromRdfType.isJust()) {
+            snippetDeclarations.push(SnippetDeclarations.sparqlInstancesOfPattern);
+        }
+        if ((this.features.has("json") || this.features.has("rdf")) &&
             this.parentObjectTypes.length > 0) {
             snippetDeclarations.push(SnippetDeclarations.UnwrapR);
         }
+        recursionStack.push(this);
         for (const property of this.ownProperties) {
-            snippetDeclarations.push(...property.snippetDeclarations);
+            snippetDeclarations.push(...property.snippetDeclarations({
+                features: this.features,
+                recursionStack,
+            }));
         }
+        invariant(Object.is(recursionStack.pop(), this));
         return snippetDeclarations;
     }
-    sparqlConstructTemplateTriples({ context, variables, }) {
-        switch (context) {
-            case "property":
-                return super.sparqlConstructTemplateTriples({ context, variables });
-            case "type":
+    sparqlConstructTemplateTriples(parameters) {
+        switch (parameters.context) {
+            case "object":
+                return super.sparqlConstructTemplateTriples(parameters);
+            case "subject":
                 return [
-                    `...${this.name}.sparqlConstructTemplateTriples(${objectInitializer({
-                        ignoreRdfType: true, // Can ignore the rdf:type when the object is nested
-                        subject: variables.subject,
-                        variablePrefix: variables.variablePrefix,
+                    `...${this.staticModuleName}.${syntheticNamePrefix}sparqlConstructTemplateTriples(${objectInitializer({
+                        ignoreRdfType: parameters.allowIgnoreRdfType ? true : undefined, // Can ignore the rdf:type when the object is nested
+                        subject: parameters.variables.subject,
+                        variablePrefix: parameters.variables.variablePrefix,
                     })})`,
                 ];
         }
     }
-    sparqlWherePatterns({ context, variables, }) {
-        switch (context) {
-            case "property":
-                return super.sparqlWherePatterns({ context, variables });
-            case "type":
+    sparqlWherePatterns(parameters) {
+        switch (parameters.context) {
+            case "object":
+                return super.sparqlWherePatterns(parameters);
+            case "subject":
                 return [
-                    `...${this.name}.sparqlWherePatterns(${objectInitializer({
-                        ignoreRdfType: true, // Can ignore the rdf:type when the object is nested
-                        subject: variables.subject,
-                        variablePrefix: variables.variablePrefix,
+                    `...${this.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns(${objectInitializer({
+                        ignoreRdfType: parameters.allowIgnoreRdfType ? true : undefined, // Can ignore the rdf:type when the object is nested
+                        subject: parameters.variables.subject,
+                        variablePrefix: parameters.variables.variablePrefix,
                     })})`,
                 ];
         }
@@ -302,20 +310,20 @@ export class ObjectType extends DeclaredType {
     toJsonExpression({ variables, }) {
         switch (this.declarationType) {
             case "class":
-                return `${variables.value}.toJson()`;
+                return `${variables.value}.${syntheticNamePrefix}toJson()`;
             case "interface":
-                return `${this.name}.toJson(${variables.value})`;
+                return `${this.staticModuleName}.${syntheticNamePrefix}toJson(${variables.value})`;
         }
     }
     toRdfExpression({ variables, }) {
         switch (this.declarationType) {
             case "class":
-                return `${variables.value}.toRdf({ mutateGraph: ${variables.mutateGraph}, resourceSet: ${variables.resourceSet} })`;
+                return `${variables.value}.${syntheticNamePrefix}toRdf({ mutateGraph: ${variables.mutateGraph}, resourceSet: ${variables.resourceSet} })`;
             case "interface":
-                return `${this.name}.toRdf(${variables.value}, { mutateGraph: ${variables.mutateGraph}, resourceSet: ${variables.resourceSet} })`;
+                return `${this.staticModuleName}.${syntheticNamePrefix}toRdf(${variables.value}, { mutateGraph: ${variables.mutateGraph}, resourceSet: ${variables.resourceSet} })`;
         }
     }
-    useImports(_features) {
+    useImports() {
         return this.imports;
     }
     ensureAtMostOneSuperObjectType() {
@@ -323,6 +331,11 @@ export class ObjectType extends DeclaredType {
             throw new RangeError(`object type '${this.name}' has multiple super object types`);
         }
     }
+    lazyAncestorObjectTypes;
+    lazyChildObjectTypes;
+    lazyDescendantObjectTypes;
+    lazyParentObjectTypes;
+    lazyProperties;
 }
 __decorate([
     Memoize()
@@ -332,10 +345,10 @@ __decorate([
 ], ObjectType.prototype, "ancestorObjectTypes", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "conversions", null);
+], ObjectType.prototype, "childObjectTypes", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "declarationImports", null);
+], ObjectType.prototype, "conversions", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "descendantObjectTypes", null);
@@ -350,10 +363,10 @@ __decorate([
 ], ObjectType.prototype, "equalsFunction", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "hashFunctionName", null);
+], ObjectType.prototype, "fromRdfTypeVariable", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "hashShaclPropertiesFunctionName", null);
+], ObjectType.prototype, "graphqlName", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "identifierProperty", null);
@@ -362,16 +375,16 @@ __decorate([
 ], ObjectType.prototype, "identifierType", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "jsonName", null);
+], ObjectType.prototype, "identifierTypeAlias", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "jsonUiSchemaFunctionName", null);
+], ObjectType.prototype, "jsonName", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "jsonZodSchemaFunctionName", null);
+], ObjectType.prototype, "mutable", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "mutable", null);
+], ObjectType.prototype, "objectSetMethodNames", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "ownProperties", null);
@@ -384,12 +397,20 @@ __decorate([
 __decorate([
     Memoize()
 ], ObjectType.prototype, "properties", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "toRdfjsResourceType", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "thisVariable", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "useImports", null);
 (function (ObjectType) {
+    ObjectType.EagerShaclProperty = _ObjectType.EagerShaclProperty;
     ObjectType.IdentifierPrefixProperty = _ObjectType.IdentifierPrefixProperty;
     ObjectType.IdentifierProperty = _ObjectType.IdentifierProperty;
+    ObjectType.LazyShaclProperty = _ObjectType.LazyShaclProperty;
     ObjectType.Property = _ObjectType.Property;
     ObjectType.ShaclProperty = _ObjectType.ShaclProperty;
     ObjectType.TypeDiscriminatorProperty = _ObjectType.TypeDiscriminatorProperty;

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

@@ -1,9 +1,33 @@
 import { Maybe } from "purify-ts";
 import { type ModuleDeclarationStructure, type TypeAliasDeclarationStructure } from "ts-morph";
 import { DeclaredType } from "./DeclaredType.js";
+import type { IdentifierType } from "./IdentifierType.js";
 import type { Import } from "./Import.js";
 import type { ObjectType } from "./ObjectType.js";
-import type { Type } from "./Type.js";
+import { Type } from "./Type.js";
+declare class MemberType {
+    private readonly delegate;
+    private readonly universe;
+    constructor({ delegate, universe, }: {
+        delegate: ObjectType;
+        universe: readonly ObjectType[];
+    });
+    get declarationType(): import("../../enums/TsObjectDeclarationType.js").TsObjectDeclarationType;
+    get discriminatorPropertyValues(): readonly string[];
+    get features(): Set<import("../../enums/TsFeature.js").TsFeature>;
+    get fromRdfType(): Maybe<import("@rdfjs/types").NamedNode<string>>;
+    get fromRdfTypeVariable(): Maybe<string>;
+    get graphqlName(): Type.GraphqlName;
+    get identifierTypeAlias(): string;
+    get jsonName(): Type.JsonName;
+    get mutable(): boolean;
+    get name(): string;
+    get staticModuleName(): string;
+    get toRdfjsResourceType(): string;
+    jsonZodSchema(parameters: Parameters<DeclaredType["jsonZodSchema"]>[0]): string;
+    snippetDeclarations(parameters: Parameters<DeclaredType["snippetDeclarations"]>[0]): readonly string[];
+    useImports(): readonly Import[];
+}
 /**
  * A union of object types, generated as a type alias
  *
@@ -15,14 +39,17 @@ import type { Type } from "./Type.js";
  * It also generates SPARQL graph patterns that UNION the member object types.
  */
 export declare class ObjectUnionType extends DeclaredType {
-    readonly kind = "ObjectUnionType";
     private readonly _discriminatorProperty;
     private readonly comment;
     private readonly label;
-    private readonly memberTypes;
-    constructor({ comment, label, memberTypes, ...superParameters }: ConstructorParameters<typeof DeclaredType>[0] & {
+    readonly identifierType: IdentifierType;
+    readonly kind = "ObjectUnionType";
+    readonly memberTypes: readonly MemberType[];
+    readonly typeof = "object";
+    constructor({ comment, identifierType, label, memberTypes, ...superParameters }: ConstructorParameters<typeof DeclaredType>[0] & {
         comment: Maybe<string>;
         export_: boolean;
+        identifierType: IdentifierType;
         label: Maybe<string>;
         memberTypes: readonly ObjectType[];
         name: string;
@@ -32,13 +59,20 @@ export declare class ObjectUnionType extends DeclaredType {
     get declarations(): (ModuleDeclarationStructure | TypeAliasDeclarationStructure)[];
     get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
     get equalsFunction(): string;
-    get jsonName(): string;
+    get graphqlName(): Type.GraphqlName;
+    get identifierTypeAlias(): string;
+    get jsonName(): Type.JsonName;
     get mutable(): boolean;
+    get objectSetMethodNames(): ObjectType.ObjectSetMethodNames;
+    get staticModuleName(): string;
     protected get thisVariable(): string;
     private get equalsFunctionDeclaration();
     private get fromJsonFunctionDeclaration();
     private get fromRdfFunctionDeclaration();
+    private get graphqlTypeVariableStatement();
     private get hashFunctionDeclaration();
+    private get identifierTypeDeclarations();
+    private get jsonTypeAliasDeclaration();
     private get jsonZodSchemaFunctionDeclaration();
     private get sparqlFunctionDeclarations();
     private get toJsonFunctionDeclaration();
@@ -46,13 +80,20 @@ export declare class ObjectUnionType extends DeclaredType {
     private get typeAliasDeclaration();
     fromJsonExpression({ variables, }: Parameters<Type["fromJsonExpression"]>[0]): string;
     fromRdfExpression({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): string;
+    graphqlResolveExpression({ variables, }: {
+        variables: {
+            value: string;
+        };
+    }): string;
     hashStatements({ variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
+    jsonUiSchemaElement(): Maybe<string>;
     jsonZodSchema(): ReturnType<Type["jsonZodSchema"]>;
-    sparqlConstructTemplateTriples({ context, variables, }: Parameters<Type["sparqlConstructTemplateTriples"]>[0]): readonly string[];
-    sparqlWherePatterns({ context, variables, }: Parameters<Type["sparqlWherePatterns"]>[0]): readonly string[];
+    snippetDeclarations(parameters: Parameters<DeclaredType["snippetDeclarations"]>[0]): readonly string[];
+    sparqlConstructTemplateTriples(parameters: Parameters<Type["sparqlConstructTemplateTriples"]>[0]): readonly string[];
+    sparqlWherePatterns(parameters: Parameters<Type["sparqlWherePatterns"]>[0]): readonly string[];
     toJsonExpression({ variables, }: Parameters<Type["toJsonExpression"]>[0]): string;
     toRdfExpression({ variables, }: Parameters<Type["toRdfExpression"]>[0]): string;
     useImports(): readonly Import[];
-    private rdfjsResourceType;
 }
+export {};
 //# sourceMappingURL=ObjectUnionType.d.ts.map