@shaclmate/compiler 4.0.70 → 4.0.71

package/dist/generators/ts/DefaultValueType.js

@@ -35,9 +35,6 @@ export class DefaultValueType extends AbstractContainerType {
     get equalsFunction() {
         return this.itemType.equalsFunction;
     }
-    get expression() {
-        return this.itemType.expression;
-    }
     get filterFunction() {
         return this.itemType.filterFunction;
     }
@@ -68,6 +65,9 @@ export class DefaultValueType extends AbstractContainerType {
     get valueSparqlWherePatternsFunction() {
         return code `${this.reusables.snippets.defaultValueSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction})`;
     }
+    get inlineExpression() {
+        return this.itemType.expression;
+    }
     get schemaInitializers() {
         return super.schemaInitializers.concat(code `defaultValue: ${this.rdfjsTermExpression(this.defaultValue)}`);
     }
@@ -85,7 +85,7 @@ export class DefaultValueType extends AbstractContainerType {
                 throw new RangeError(`not implemented ${this.itemType.kind}`);
         }
         invariant(this.defaultValue.termType === "Literal");
-        return this.itemType.literalValueExpression(this.defaultValue);
+        return this.itemType.valueExpression(this.defaultValue);
     }
     fromJsonExpression(parameters) {
         return this.itemType.fromJsonExpression(parameters);

package/dist/generators/ts/DiscriminatedUnionType.d.ts

@@ -22,10 +22,9 @@ export declare class DiscriminatedUnionType<MemberTypeT extends Type> extends Ab
         synthetic: boolean;
     } & ConstructorParameters<typeof AbstractType>[0]);
     get conversionFunction(): Maybe<AbstractType.ConversionFunction>;
-    get declaration(): Maybe<Code>;
     get discriminantProperty(): Maybe<AbstractType.DiscriminantProperty>;
     get equalsFunction(): Code;
-    get expression(): Code;
+    protected get inlineExpression(): Code;
     get filterFunction(): Code;
     get filterType(): Code;
     get fromRdfResourceValuesFunction(): Code;
@@ -37,13 +36,12 @@ export declare class DiscriminatedUnionType<MemberTypeT extends Type> extends Ab
     get members(): readonly DiscriminatedUnionType.Member<MemberTypeT>[];
     get mutable(): boolean;
     get referencesNamedType(): boolean;
-    get schema(): Code;
     get schemaType(): Code;
     get toRdfResourceValueTypes(): AbstractType["toRdfResourceValueTypes"];
     get valueSparqlConstructTriplesFunction(): Code;
     get valueSparqlWherePatternsFunction(): Code;
     protected get schemaInitializers(): readonly Code[];
-    protected get staticModuleDeclarations(): Record<string, Code>;
+    protected staticModuleDeclarations(name: string): Record<string, Code>;
     fromJsonExpression({ variables, }: Parameters<AbstractType["fromJsonExpression"]>[0]): Code;
     graphqlResolveExpression({ variables, }: {
         variables: {

package/dist/generators/ts/DiscriminatedUnionType.js

@@ -24,7 +24,7 @@ import { DiscriminatedUnionType_toStringFunctionExpression } from "./_Discrimina
 import { DiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression } from "./_DiscriminatedUnionType/DiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression.js";
 import { DiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression } from "./_DiscriminatedUnionType/DiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression.js";
 import { AbstractType } from "./AbstractType.js";
-import { code, def, joinCode, literalOf, } from "./ts-poet-wrapper.js";
+import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
 export class DiscriminatedUnionType extends AbstractType {
     discriminant;
     graphqlArgs = Maybe.empty();
@@ -143,26 +143,6 @@ export class DiscriminatedUnionType extends AbstractType {
                 ],
         });
     }
-    get declaration() {
-        const name = this.name.extract();
-        if (!name) {
-            return Maybe.empty();
-        }
-        const declarations = [];
-        if (this.configuration.features.has("Object.type")) {
-            declarations.push(code `export type ${def(name)} = ${DiscriminatedUnionType_inlineExpression.call(this)};`);
-        }
-        const staticModuleDeclarations = Object.entries(this.staticModuleDeclarations);
-        if (staticModuleDeclarations.length > 0) {
-            declarations.push(code `\
-export namespace ${def(name)} {
-${joinCode(staticModuleDeclarations
-                .sort((left, right) => left[0].localeCompare(right[0]))
-                .map((_) => _[1]), { on: "\n\n" })}
-}`);
-        }
-        return Maybe.of(joinCode(declarations, { on: "\n\n" }));
-    }
     get discriminantProperty() {
         switch (this.discriminant.kind) {
             case "Extrinsic":
@@ -194,10 +174,8 @@ ${joinCode(staticModuleDeclarations
             .map((name) => code `${name}.equals`)
             .orDefault(DiscriminatedUnionType_equalsFunctionExpression.call(this));
     }
-    get expression() {
-        return this.name
-            .map((name) => code `${name}`)
-            .orDefault(DiscriminatedUnionType_inlineExpression.call(this));
+    get inlineExpression() {
+        return DiscriminatedUnionType_inlineExpression.call(this);
     }
     get filterFunction() {
         return this.name
@@ -267,11 +245,6 @@ ${joinCode(staticModuleDeclarations
         return (this.name.isJust() ||
             this.members.some((member) => member.type.referencesNamedType));
     }
-    get schema() {
-        return this.name
-            .map((name) => code `${name}.schema`)
-            .orDefault(this.schemaExpression);
-    }
     get schemaType() {
         return this.name
             .map(() => code `typeof ${this.schema}`)
@@ -302,29 +275,30 @@ ${joinCode(staticModuleDeclarations
             type: type.schema,
         }}`), { on: "," })} }`);
     }
-    get staticModuleDeclarations() {
-        const name = this.name.unsafeCoerce();
-        const staticModuleDeclarations = {};
+    staticModuleDeclarations(name) {
+        const staticModuleDeclarations = {
+            ...super.staticModuleDeclarations(name),
+        };
         if (this.configuration.features.has("Object.equals")) {
-            staticModuleDeclarations[`equals`] =
+            staticModuleDeclarations["equals"] =
                 code `export const equals = ${DiscriminatedUnionType_equalsFunctionExpression.call(this)};`;
         }
         if (this.configuration.features.has("Object.filter")) {
-            staticModuleDeclarations[`Filter`] =
+            staticModuleDeclarations["Filter"] =
                 code `export type Filter = ${DiscriminatedUnionType_filterTypeExpression.call(this)};`;
-            staticModuleDeclarations[`filter`] =
+            staticModuleDeclarations["filter"] =
                 code `export const filter = ${DiscriminatedUnionType_filterFunctionExpression.call(this)};`;
         }
         if (this.configuration.features.has("Object.hash")) {
-            staticModuleDeclarations[`hash`] =
+            staticModuleDeclarations["hash"] =
                 code `export const hash = ${DiscriminatedUnionType_hashFunctionExpression.call(this)};`;
         }
         if (this.configuration.features.has("Object.JSON.type")) {
-            staticModuleDeclarations[`Json.type`] =
+            staticModuleDeclarations["Json.type"] =
                 code `${this.jsonTypeAliasDeclaration}`;
         }
         if (this.configuration.features.has("Object.JSON.schema")) {
-            staticModuleDeclarations[`Json.namespace`] = code `\
+            staticModuleDeclarations["Json.namespace"] = code `\
 export namespace Json {
   ${this.jsonSchemaFunctionDeclaration}
 
@@ -336,29 +310,25 @@ export namespace Json {
 }`;
         }
         if (this.configuration.features.has("Object.fromJson")) {
-            staticModuleDeclarations[`fromJson`] =
+            staticModuleDeclarations["fromJson"] =
                 code `export const fromJson = ${DiscriminatedUnionType_fromJsonFunctionExpression.call(this)};`;
         }
         if (this.configuration.features.has("Object.fromRdf")) {
-            staticModuleDeclarations[`fromRdfResourceValues`] =
+            staticModuleDeclarations["fromRdfResourceValues"] =
                 code `export const fromRdfResourceValues: ${this.reusables.snippets.FromRdfResourceValuesFunction}<${name}, ${this.schemaType}> = ${DiscriminatedUnionType_fromRdfResourceValuesFunctionExpression.call(this)};`;
         }
-        if (this.configuration.features.has("Object.schema")) {
-            staticModuleDeclarations["schema"] =
-                code `export const schema = ${this.schemaExpression}`;
-        }
         if (this.configuration.features.has("Object.toJson")) {
-            staticModuleDeclarations[`toJson`] =
+            staticModuleDeclarations["toJson"] =
                 code `export const toJson = ${DiscriminatedUnionType_toJsonFunctionExpression.call(this)};`;
         }
         if (this.configuration.features.has("Object.toRdf")) {
-            staticModuleDeclarations[`toRdfResourceValues`] =
+            staticModuleDeclarations["toRdfResourceValues"] =
                 code `export const toRdfResourceValues = ${DiscriminatedUnionType_toRdfResourceValuesFunctionExpression.call(this)};`;
         }
         if (this.configuration.features.has("Object.SPARQL")) {
-            staticModuleDeclarations[`valueSparqlConstructTriples`] =
+            staticModuleDeclarations["valueSparqlConstructTriples"] =
                 code `export const valueSparqlConstructTriples: ${this.reusables.snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}> = ${DiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression.call(this)};`;
-            staticModuleDeclarations[`valueSparqlWherePatterns`] =
+            staticModuleDeclarations["valueSparqlWherePatterns"] =
                 code `export const valueSparqlWherePatterns: ${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}> = ${DiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression.call(this)};`;
         }
         if (this.configuration.features.has("Object.toString")) {
@@ -406,9 +376,6 @@ export namespace Json {
 __decorate([
     Memoize()
 ], DiscriminatedUnionType.prototype, "conversionFunction", null);
-__decorate([
-    Memoize()
-], DiscriminatedUnionType.prototype, "declaration", null);
 __decorate([
     Memoize()
 ], DiscriminatedUnionType.prototype, "discriminantProperty", null);
@@ -417,7 +384,7 @@ __decorate([
 ], DiscriminatedUnionType.prototype, "equalsFunction", null);
 __decorate([
     Memoize()
-], DiscriminatedUnionType.prototype, "expression", null);
+], DiscriminatedUnionType.prototype, "inlineExpression", null);
 __decorate([
     Memoize()
 ], DiscriminatedUnionType.prototype, "filterFunction", null);
@@ -442,9 +409,6 @@ __decorate([
 __decorate([
     Memoize()
 ], DiscriminatedUnionType.prototype, "mutable", null);
-__decorate([
-    Memoize()
-], DiscriminatedUnionType.prototype, "schema", null);
 __decorate([
     Memoize()
 ], DiscriminatedUnionType.prototype, "schemaType", null);

package/dist/generators/ts/FloatType.d.ts

@@ -8,6 +8,6 @@ export declare class FloatType extends AbstractNumericType<number> {
     readonly kind = "Float";
     get fromRdfResourceValuesFunction(): Code;
     get graphqlType(): import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
-    literalValueExpression(literal: Literal | number): Code;
+    valueExpression(literal: Literal | number): Code;
 }
 //# sourceMappingURL=FloatType.d.ts.map

package/dist/generators/ts/FloatType.js

@@ -17,7 +17,7 @@ export class FloatType extends AbstractNumericType {
     get graphqlType() {
         return new AbstractNumericType.GraphqlType(code `${this.reusables.imports.GraphQLFloat}`, this.reusables);
     }
-    literalValueExpression(literal) {
+    valueExpression(literal) {
         return code `${typeof literal === "number" ? literal : LiteralDecoder.decodeFloatLiteral(literal).unsafeCoerce()}`;
     }
 }

package/dist/generators/ts/IntType.d.ts

@@ -8,6 +8,6 @@ export declare class IntType extends AbstractNumericType<number> {
     readonly kind = "Int";
     get fromRdfResourceValuesFunction(): Code;
     get graphqlType(): import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
-    literalValueExpression(literal: Literal | number): Code;
+    valueExpression(literal: Literal | number): Code;
 }
 //# sourceMappingURL=IntType.d.ts.map

package/dist/generators/ts/IntType.js

@@ -17,7 +17,7 @@ export class IntType extends AbstractNumericType {
     get graphqlType() {
         return new AbstractNumericType.GraphqlType(code `${this.reusables.imports.GraphQLInt}`, this.reusables);
     }
-    literalValueExpression(literal) {
+    valueExpression(literal) {
         return code `${typeof literal === "number" ? literal : LiteralDecoder.decodeIntLiteral(literal).unsafeCoerce()}`;
     }
 }

package/dist/generators/ts/IriType.d.ts

@@ -13,7 +13,9 @@ export declare class IriType extends AbstractIdentifierType<NamedNode> {
     get fromRdfResourceValuesFunction(): Code;
     get parseFunction(): Code;
     protected get inlineExpression(): Code;
+    protected staticModuleDeclarations(name: string): Record<string, Code>;
     protected get schemaInitializers(): readonly Code[];
+    protected get inlineValueTypeExpression(): Code;
     private get valueTypeExpression();
     fromJsonExpression({ variables, }: Parameters<AbstractIdentifierType<NamedNode>["fromJsonExpression"]>[0]): Code;
     jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractIdentifierType<NamedNode>["jsonSchema"]>[0]): Code;

package/dist/generators/ts/IriType.js

@@ -8,7 +8,7 @@ import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
-import { arrayOf, code, joinCode } from "./ts-poet-wrapper.js";
+import { arrayOf, code, joinCode, literalOf, } from "./ts-poet-wrapper.js";
 export class IriType extends AbstractIdentifierType {
     filterFunction = code `${this.reusables.snippets.filterIri}`;
     filterType = code `${this.reusables.snippets.IriFilter}`;
@@ -43,21 +43,45 @@ export class IriType extends AbstractIdentifierType {
     }
     get inlineExpression() {
         if (this.in_.length > 0) {
-            return code `${this.reusables.imports.NamedNode}<${this.valueTypeExpression}>`;
+            return code `${this.reusables.imports.NamedNode}<${this.inlineValueTypeExpression}>`;
         }
         return code `${this.reusables.imports.NamedNode}`;
     }
+    staticModuleDeclarations(name) {
+        if (this.in_.length === 0) {
+            return super.staticModuleDeclarations(name);
+        }
+        return {
+            ...super.staticModuleDeclarations(name),
+            inValues: code `const inValues = ${arrayOf(...this.in_.map((in_) => in_.value))} as const;`,
+        };
+    }
     get schemaInitializers() {
-        let initializers = super.schemaInitializers;
-        if (this.in_.length > 0) {
-            initializers = initializers.concat(code `in: ${arrayOf(...this.in_.map((in_) => this.rdfjsTermExpression(in_)))}`);
+        if (this.in_.length === 0 || this.name.isNothing()) {
+            return super.schemaInitializers;
         }
+        let initializers = [code `kind: ${literalOf(this.kind)} as const`];
+        if (this.hasValues.length > 0) {
+            initializers = initializers.concat(code `hasValues: ${arrayOf(...this.hasValues.map((hasValue) => this.rdfjsTermExpression(hasValue)))}`);
+        }
+        initializers = initializers.concat(code `in: inValues.map(inValue => ${this.reusables.imports.dataFactory}.namedNode(inValue))`, code `inValues`);
         return initializers;
     }
+    get inlineValueTypeExpression() {
+        if (this.in_.length === 0) {
+            return code `string`;
+        }
+        const name = this.name.extract();
+        if (name && this.configuration.features.has("Object.schema")) {
+            // Reuse the type from schema to cut down code
+            return code `(typeof ${name}.schema)["inValues"][number]`;
+        }
+        return code `(${this.in_.map((in_) => `"${in_.value}"`).join(" | ")})`;
+    }
     get valueTypeExpression() {
-        return this.in_.length > 0
-            ? code `(${this.in_.map((in_) => `"${in_.value}"`).join(" | ")})`
-            : code `string`;
+        return this.name
+            .map((name) => code `${name}["value"]`)
+            .orDefaultLazy(() => this.inlineValueTypeExpression);
     }
     fromJsonExpression({ variables, }) {
         return code `${this.reusables.imports.Either}.of<Error, ${this.expression}>(${this.reusables.imports.dataFactory}.namedNode(${variables.value}["@id"]))`;
@@ -65,9 +89,14 @@ export class IriType extends AbstractIdentifierType {
     jsonSchema({ includeDiscriminantProperty, }) {
         let idSchema;
         if (this.in_.length > 0) {
-            // Treat sh:in as a union of the IRIs
-            // rdfjs.NamedNode<"http://example.com/1" | "http://example.com/2">
-            idSchema = code `${this.reusables.imports.z}.enum(${arrayOf(...this.in_.map((iri) => iri.value))})`;
+            const name = this.name.extract();
+            if (name && this.configuration.features.has("Object.schema")) {
+                // Reuse the type from schema to cut down code
+                idSchema = code `${this.reusables.imports.z}.enum(${name}.schema.in.map(_ => _.value))`;
+            }
+            else {
+                idSchema = code `${this.reusables.imports.z}.enum(${arrayOf(...this.in_.map((iri) => iri.value))})`;
+            }
         }
         else {
             idSchema = code `${this.reusables.imports.z}.string().min(1)`;
@@ -102,6 +131,9 @@ __decorate([
 __decorate([
     Memoize()
 ], IriType.prototype, "inlineExpression", null);
+__decorate([
+    Memoize()
+], IriType.prototype, "inlineValueTypeExpression", null);
 __decorate([
     Memoize()
 ], IriType.prototype, "valueTypeExpression", null);

package/dist/generators/ts/LangStringType.d.ts

@@ -25,7 +25,7 @@ export declare class LangStringType extends AbstractLiteralType {
     graphqlResolveExpression(_parameters: Parameters<AbstractLiteralType["graphqlResolveExpression"]>[0]): Code;
     jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractLiteralType["jsonSchema"]>[0]): Code;
     jsonType(parameters?: Parameters<AbstractLiteralType["jsonType"]>[0]): AbstractLiteralType.JsonType;
-    literalValueExpression(literal: Literal): Code;
+    valueExpression(literal: Literal): Code;
     toJsonExpression({ includeDiscriminantProperty, variables, }: Parameters<AbstractLiteralType["toJsonExpression"]>[0]): Code;
 }
 //# sourceMappingURL=LangStringType.d.ts.map

package/dist/generators/ts/LangStringType.js

@@ -31,9 +31,6 @@ export class LangStringType extends AbstractLiteralType {
     }
     get schemaInitializers() {
         let initializers = super.schemaInitializers;
-        if (this.in_.length > 0) {
-            initializers = initializers.concat(code `in: ${arrayOf(...this.in_.map((in_) => this.rdfjsTermExpression(in_)))}`);
-        }
         if (this.languageIn.length > 0) {
             initializers = initializers.concat(code `languageIn: ${arrayOf(...this.languageIn)}`);
         }
@@ -57,7 +54,7 @@ export class LangStringType extends AbstractLiteralType {
             : "";
         return new AbstractLiteralType.JsonType(code `{ readonly "@language": string${discriminantProperty}, readonly "@value": string }`);
     }
-    literalValueExpression(literal) {
+    valueExpression(literal) {
         return this.rdfjsTermExpression(literal);
     }
     toJsonExpression({ includeDiscriminantProperty, variables, }) {

package/dist/generators/ts/LiteralType.d.ts

@@ -25,7 +25,7 @@ export declare class LiteralType extends AbstractLiteralType {
     graphqlResolveExpression(_parameters: Parameters<AbstractLiteralType["graphqlResolveExpression"]>[0]): Code;
     jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractLiteralType["jsonSchema"]>[0]): Code;
     jsonType(parameters?: Parameters<AbstractLiteralType["jsonType"]>[0]): AbstractLiteralType.JsonType;
-    literalValueExpression(literal: Literal): Code;
+    valueExpression(literal: Literal): Code;
     toJsonExpression({ includeDiscriminantProperty, variables, }: Parameters<AbstractLiteralType["toJsonExpression"]>[0]): Code;
 }
 //# sourceMappingURL=LiteralType.d.ts.map

package/dist/generators/ts/LiteralType.js

@@ -40,9 +40,6 @@ export class LiteralType extends AbstractLiteralType {
     }
     get schemaInitializers() {
         let initializers = super.schemaInitializers;
-        if (this.in_.length > 0) {
-            initializers = initializers.concat(code `in: ${arrayOf(...this.in_.map((in_) => this.rdfjsTermExpression(in_)))}`);
-        }
         if (this.languageIn.length > 0) {
             initializers = initializers.concat(code `languageIn: ${arrayOf(...this.languageIn)}`);
         }
@@ -66,7 +63,7 @@ export class LiteralType extends AbstractLiteralType {
             : "";
         return new AbstractLiteralType.JsonType(code `{ readonly "@language"?: string${discriminantProperty}, readonly "@type"?: string, readonly "@value": string }`);
     }
-    literalValueExpression(literal) {
+    valueExpression(literal) {
         return this.rdfjsTermExpression(literal);
     }
     toJsonExpression({ includeDiscriminantProperty, variables, }) {

package/dist/generators/ts/ObjectDiscriminatedUnionType.d.ts

@@ -6,9 +6,8 @@ export declare class ObjectDiscriminatedUnionType extends DiscriminatedUnionType
     readonly kind = "ObjectDiscriminatedUnion";
     get identifierTypeAlias(): Code;
     get objectSetMethodNames(): ObjectType.ObjectSetMethodNames;
-    get schema(): Code;
     get schemaType(): Code;
     get typeGuardFunction(): Maybe<Code>;
-    protected get staticModuleDeclarations(): Record<string, Code>;
+    protected staticModuleDeclarations(name: string): Record<string, Code>;
 }
 //# sourceMappingURL=ObjectDiscriminatedUnionType.d.ts.map

package/dist/generators/ts/ObjectDiscriminatedUnionType.js

@@ -33,11 +33,6 @@ export class ObjectDiscriminatedUnionType extends DiscriminatedUnionType {
         }))
             .unsafeCoerce();
     }
-    get schema() {
-        return this.name
-            .map((name) => code `${name}.schema`)
-            .orDefault(super.schema);
-    }
     get schemaType() {
         return this.name
             .map(() => code `typeof ${this.schema}`)
@@ -49,10 +44,9 @@ export class ObjectDiscriminatedUnionType extends DiscriminatedUnionType {
         }
         return this.name.map((name) => code `${name}.is${name}`);
     }
-    get staticModuleDeclarations() {
-        const name = this.name.unsafeCoerce();
+    staticModuleDeclarations(name) {
         return {
-            ...super.staticModuleDeclarations,
+            ...super.staticModuleDeclarations(name),
             ...ObjectDiscriminatedUnionType_identifierTypeDeclarations.call(this),
             ...ObjectDiscriminatedUnionType_focusSparqlConstructTriplesFunctionDeclaration.call(this),
             ...ObjectDiscriminatedUnionType_focusSparqlWherePatternsFunctionDeclaration.call(this),
@@ -86,9 +80,6 @@ __decorate([
 __decorate([
     Memoize()
 ], ObjectDiscriminatedUnionType.prototype, "objectSetMethodNames", null);
-__decorate([
-    Memoize()
-], ObjectDiscriminatedUnionType.prototype, "schema", null);
 __decorate([
     Memoize()
 ], ObjectDiscriminatedUnionType.prototype, "schemaType", null);

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

@@ -38,9 +38,9 @@ export declare class ObjectType extends AbstractType {
         toRdfTypes: readonly NamedNode[];
     } & ConstructorParameters<typeof AbstractType>[0]);
     get conversionFunction(): Maybe<AbstractType.ConversionFunction>;
+    protected staticModuleDeclarations(name: string): Record<string, Code>;
     get declaration(): Maybe<Code>;
     get equalsFunction(): Code;
-    get expression(): Code;
     get filterFunction(): Code;
     get filterType(): Code;
     get fromRdfResourceValuesFunction(): Code;
@@ -52,7 +52,7 @@ export declare class ObjectType extends AbstractType {
     get objectSetMethodNames(): ObjectType.ObjectSetMethodNames;
     get properties(): readonly ObjectType.Property[];
     get referencesNamedType(): boolean;
-    get schema(): Code;
+    get schemaExpression(): Code;
     get schemaType(): Code;
     get toRdfResourceValueTypes(): AbstractType["toRdfResourceValueTypes"];
     get toRdfjsResourceType(): Code;
@@ -72,7 +72,7 @@ export declare class ObjectType extends AbstractType {
     protected get toJsonFunction(): Code;
     protected get toRdfTypesVariable(): Maybe<Code>;
     protected get toStringFunction(): Code;
-    private get inlineExpression();
+    protected get inlineExpression(): Code;
     fromJsonExpression({ variables, }: Parameters<AbstractType["fromJsonExpression"]>[0]): Code;
     graphqlResolveExpression({ variables, }: {
         variables: {