@shaclmate/compiler 2.0.22 → 2.0.24

package/dist/generators/ts/ObjectType.d.ts

@@ -1,44 +1,46 @@
 import type { NamedNode } from "@rdfjs/types";
 import { Maybe } from "purify-ts";
 import { type ClassDeclarationStructure, type InterfaceDeclarationStructure, type ModuleDeclarationStructure } from "ts-morph";
-import type { IdentifierMintingStrategy, TsFeature, TsObjectDeclarationType } from "../../enums/index.js";
+import * as _ObjectType from "./_ObjectType/index.js";
+import type { IdentifierMintingStrategy, TsObjectDeclarationType } from "../../enums/index.js";
 import { DeclaredType } from "./DeclaredType.js";
 import type { IdentifierType } from "./IdentifierType.js";
 import { Import } from "./Import.js";
-import type { Type } from "./Type.js";
-import * as _ObjectType from "./_ObjectType/index.js";
+import { Type } from "./Type.js";
 export declare class ObjectType extends DeclaredType {
-    readonly abstract: boolean;
-    readonly declarationType: TsObjectDeclarationType;
-    readonly kind = "ObjectType";
+    private readonly imports;
     protected readonly comment: Maybe<string>;
-    protected readonly extern: boolean;
-    protected readonly fromRdfType: Maybe<NamedNode>;
     protected readonly label: Maybe<string>;
-    protected readonly identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
     protected readonly toRdfTypes: readonly NamedNode[];
-    private readonly imports;
-    private readonly lazyAncestorObjectTypes;
-    private readonly lazyDescendantObjectTypes;
-    private readonly lazyParentObjectTypes;
-    private readonly lazyProperties;
-    constructor({ abstract, comment, declarationType, extern, fromRdfType, label, lazyAncestorObjectTypes, lazyDescendantObjectTypes, lazyParentObjectTypes, lazyProperties, imports, identifierMintingStrategy, toRdfTypes, ...superParameters }: {
+    readonly abstract: boolean;
+    readonly declarationType: TsObjectDeclarationType;
+    readonly extern: boolean;
+    readonly fromRdfType: Maybe<NamedNode>;
+    readonly kind = "ObjectType";
+    readonly staticModuleName: string;
+    readonly synthetic: boolean;
+    readonly typeof = "object";
+    constructor({ abstract, comment, declarationType, extern, fromRdfType, imports, label, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyParentObjectTypes, lazyProperties, staticModuleName, synthetic, toRdfTypes, ...superParameters }: {
         abstract: boolean;
         comment: Maybe<string>;
         declarationType: TsObjectDeclarationType;
         extern: boolean;
         fromRdfType: Maybe<NamedNode>;
+        identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
         imports: readonly string[];
         label: Maybe<string>;
         lazyAncestorObjectTypes: () => readonly ObjectType[];
+        lazyChildObjectTypes: () => readonly ObjectType[];
         lazyDescendantObjectTypes: () => readonly ObjectType[];
         lazyParentObjectTypes: () => readonly ObjectType[];
-        lazyProperties: () => readonly ObjectType.Property[];
-        identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
+        lazyProperties: (objectType: ObjectType) => readonly ObjectType.Property[];
+        staticModuleName: string;
+        synthetic: boolean;
         toRdfTypes: readonly NamedNode[];
     } & ConstructorParameters<typeof DeclaredType>[0]);
     get _discriminatorProperty(): Type.DiscriminatorProperty;
     get ancestorObjectTypes(): readonly ObjectType[];
+    get childObjectTypes(): readonly ObjectType[];
     get conversions(): readonly Type.Conversion[];
     get declarationImports(): readonly Import[];
     get declarations(): (ClassDeclarationStructure | InterfaceDeclarationStructure | ModuleDeclarationStructure)[];
@@ -46,52 +48,72 @@ export declare class ObjectType extends DeclaredType {
     get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
     get discriminatorValue(): string;
     get equalsFunction(): string;
-    get hashFunctionName(): string;
-    get hashShaclPropertiesFunctionName(): string;
+    get fromRdfTypeVariable(): Maybe<string>;
+    get graphqlName(): Type.GraphqlName;
     get identifierProperty(): ObjectType.IdentifierProperty;
     get identifierType(): IdentifierType;
-    get jsonName(): string;
-    get jsonUiSchemaFunctionName(): string;
-    get jsonZodSchemaFunctionName(): string;
+    get identifierTypeAlias(): string;
+    get jsonName(): Type.JsonName;
     get mutable(): boolean;
+    newExpression({ parameters }: {
+        parameters: string;
+    }): string;
+    get objectSetMethodNames(): ObjectType.ObjectSetMethodNames;
     get ownProperties(): readonly ObjectType.Property[];
     get ownShaclProperties(): readonly ObjectType.Property[];
     get parentObjectTypes(): readonly ObjectType[];
     get properties(): readonly ObjectType.Property[];
+    get toRdfjsResourceType(): string;
     protected get thisVariable(): string;
-    fromJsonExpression({ variables, }: Parameters<Type["fromJsonExpression"]>[0]): string;
-    fromRdfExpression({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): string;
-    hashStatements({ variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
-    jsonUiSchemaElement({ variables, }: {
+    fromJsonExpression({ variables, }: Parameters<DeclaredType["fromJsonExpression"]>[0]): string;
+    fromRdfExpression({ variables, }: Parameters<DeclaredType["fromRdfExpression"]>[0]): string;
+    graphqlResolveExpression({ variables, }: {
         variables: {
-            scopePrefix: string;
+            value: string;
         };
-    }): Maybe<string>;
-    jsonZodSchema(_parameters: Parameters<Type["jsonZodSchema"]>[0]): ReturnType<Type["jsonZodSchema"]>;
-    rdfjsResourceType(options?: {
-        mutable?: boolean;
-    }): {
-        readonly mutable: boolean;
-        readonly name: string;
-        readonly named: boolean;
-    };
-    snippetDeclarations(): readonly string[];
-    sparqlConstructTemplateTriples({ context, variables, }: Parameters<Type["sparqlConstructTemplateTriples"]>[0]): readonly string[];
-    sparqlWherePatterns({ context, variables, }: Parameters<Type["sparqlWherePatterns"]>[0]): readonly string[];
-    toJsonExpression({ variables, }: Parameters<Type["toJsonExpression"]>[0]): string;
-    toRdfExpression({ variables, }: Parameters<Type["toRdfExpression"]>[0]): string;
-    useImports(_features: Set<TsFeature>): readonly Import[];
+    }): string;
+    hashStatements({ variables, }: Parameters<DeclaredType["hashStatements"]>[0]): readonly string[];
+    jsonUiSchemaElement({ variables, }: Parameters<DeclaredType["jsonUiSchemaElement"]>[0]): Maybe<string>;
+    jsonZodSchema({ context, variables, }: Parameters<DeclaredType["jsonZodSchema"]>[0]): ReturnType<DeclaredType["jsonZodSchema"]>;
+    snippetDeclarations({ recursionStack, }: Parameters<DeclaredType["snippetDeclarations"]>[0]): readonly string[];
+    sparqlConstructTemplateTriples(parameters: Parameters<DeclaredType["sparqlConstructTemplateTriples"]>[0]): readonly string[];
+    sparqlWherePatterns(parameters: Parameters<DeclaredType["sparqlWherePatterns"]>[0]): readonly string[];
+    toJsonExpression({ variables, }: Parameters<DeclaredType["toJsonExpression"]>[0]): string;
+    toRdfExpression({ variables, }: Parameters<DeclaredType["toRdfExpression"]>[0]): string;
+    useImports(): readonly Import[];
     protected ensureAtMostOneSuperObjectType(): void;
+    private readonly lazyAncestorObjectTypes;
+    private readonly lazyChildObjectTypes;
+    private readonly lazyDescendantObjectTypes;
+    private readonly lazyParentObjectTypes;
+    private readonly lazyProperties;
 }
 export declare namespace ObjectType {
+    const EagerShaclProperty: typeof _ObjectType.EagerShaclProperty;
+    type EagerShaclProperty<TypeT extends Type = Type> = _ObjectType.EagerShaclProperty<TypeT>;
     const IdentifierPrefixProperty: typeof _ObjectType.IdentifierPrefixProperty;
     type IdentifierPrefixProperty = _ObjectType.IdentifierPrefixProperty;
     const IdentifierProperty: typeof _ObjectType.IdentifierProperty;
     type IdentifierProperty = _ObjectType.IdentifierProperty;
+    const LazyShaclProperty: typeof _ObjectType.LazyShaclProperty;
+    type LazyShaclProperty<LazyTypeT extends _ObjectType.LazyShaclProperty.Type<ResolvedTypeT, StubTypeT>, ResolvedTypeT extends _ObjectType.LazyShaclProperty.Type.ResolvedTypeConstraint, StubTypeT extends _ObjectType.LazyShaclProperty.Type.StubTypeConstraint> = _ObjectType.LazyShaclProperty<LazyTypeT, ResolvedTypeT, StubTypeT>;
+    namespace LazyShaclProperty {
+        type Type<ResolvedTypeT extends _ObjectType.LazyShaclProperty.Type.ResolvedTypeConstraint, StubTypeT extends _ObjectType.LazyShaclProperty.Type.StubTypeConstraint> = _ObjectType.LazyShaclProperty.Type<ResolvedTypeT, StubTypeT>;
+        namespace Type {
+            type ResolvedTypeConstraint = _ObjectType.LazyShaclProperty.Type.ResolvedTypeConstraint;
+            type StubTypeConstraint = _ObjectType.LazyShaclProperty.Type.StubTypeConstraint;
+        }
+    }
+    type ObjectSetMethodNames = {
+        readonly object: string;
+        readonly objectsCount: string;
+        readonly objectIdentifiers: string;
+        readonly objects: string;
+    };
     const Property: typeof _ObjectType.Property;
     type Property = _ObjectType.Property<any>;
     const ShaclProperty: typeof _ObjectType.ShaclProperty;
-    type ShaclProperty = _ObjectType.ShaclProperty;
+    type ShaclProperty<TypeT extends Type> = _ObjectType.ShaclProperty<TypeT>;
     const TypeDiscriminatorProperty: typeof _ObjectType.TypeDiscriminatorProperty;
     type TypeDiscriminatorProperty = _ObjectType.TypeDiscriminatorProperty;
 }

package/dist/generators/ts/ObjectType.js

@@ -9,27 +9,27 @@ 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;
+    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, label, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyParentObjectTypes, lazyProperties, staticModuleName, synthetic, toRdfTypes, ...superParameters }) {
         super(superParameters);
         this.abstract = abstract;
         this.comment = comment;
@@ -40,10 +40,12 @@ export class ObjectType extends DeclaredType {
         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 +53,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 +77,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 +99,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 +134,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 +155,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 identifierTypeAlias() {
+        return `${this.staticModuleName}.${syntheticNamePrefix}Identifier`;
     }
-    get jsonUiSchemaFunctionName() {
-        if (this.ancestorObjectTypes.length > 0 ||
-            this.descendantObjectTypes.length > 0)
-            return `${camelCase(this.name)}JsonUiSchema`;
-        return "jsonUiSchema";
-    }
-    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}.${syntheticNamePrefix}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 +191,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 +200,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 +218,90 @@ 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}.chain(values => values.chainMap(value => value.toResource().chain(resource => ${this.staticModuleName}.${syntheticNamePrefix}fromRdf(resource, { ...${variables.context}, ${variables.ignoreRdfType ? "ignoreRdfType: true, " : ""}languageIn: ${variables.languageIn}, objectSet: ${variables.objectSet} }))))`;
+    }
+    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
+                        languageIn: parameters.variables.languageIn,
+                        subject: parameters.variables.subject,
+                        variablePrefix: parameters.variables.variablePrefix,
                     })})`,
                 ];
         }
@@ -302,20 +309,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 +330,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 +344,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 +362,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 +374,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 +396,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;