@shaclmate/compiler 4.0.19 → 4.0.21

package/dist/ast/ObjectType.d.ts

@@ -99,58 +99,28 @@ export declare class ObjectType extends AbstractType {
     equals(other: ObjectType): boolean;
     sortProperties(): void;
     toJSON(): {
-        fromRdfType: string | undefined;
+        fromRdfType: NamedNode<string> | undefined;
         identifierMintingStrategy: "blankNode" | "sha256" | "uuidv4" | undefined;
         identifierType: {
-            hasValues: ({
-                termType: "BlankNode";
-                value: string;
-                datatype?: undefined;
-                language?: undefined;
-            } | {
-                datatype: string;
-                language: string;
-                termType: "Literal";
-                value: string;
-            } | {
-                termType: "NamedNode";
-                value: string;
-                datatype?: undefined;
-                language?: undefined;
-            })[] | undefined;
-            in: ({
-                termType: "BlankNode";
-                value: string;
-                datatype?: undefined;
-                language?: undefined;
-            } | {
-                datatype: string;
-                language: string;
-                termType: "Literal";
-                value: string;
-            } | {
-                termType: "NamedNode";
-                value: string;
-                datatype?: undefined;
-                language?: undefined;
-            })[] | undefined;
+            hasValues: readonly NamedNode<string>[] | undefined;
+            in: readonly NamedNode<string>[] | undefined;
             nodeKinds: NodeKind[];
             comment: string | undefined;
             kind: string;
             label: string | undefined;
             name: string | undefined;
             recursive: boolean | undefined;
-            shapeIdentifier: string;
+            shapeIdentifier: BlankNode | NamedNode<string>;
         };
-        parentObjectTypes: string[] | undefined;
+        parentObjectTypes: (string | BlankNode | NamedNode<string>)[] | undefined;
         synthetic: boolean | undefined;
-        toRdfTypes: string[] | undefined;
+        toRdfTypes: readonly NamedNode<string>[] | undefined;
         comment: string | undefined;
         kind: string;
         label: string | undefined;
         name: string | undefined;
         recursive: boolean | undefined;
-        shapeIdentifier: string;
+        shapeIdentifier: BlankNode | NamedNode<string>;
     };
 }
 export declare namespace ObjectType {
@@ -227,14 +197,14 @@ export declare namespace ObjectType {
             order: number;
             path: string;
             recursive: boolean | undefined;
-            shapeIdentifier: string;
+            shapeIdentifier: BlankNode | NamedNode<string>;
             type: {
                 comment: string | undefined;
                 kind: string;
                 label: string | undefined;
                 name: string | undefined;
                 recursive: boolean | undefined;
-                shapeIdentifier: string;
+                shapeIdentifier: BlankNode | NamedNode<string>;
             };
             visibility: Visibility;
         };

package/dist/ast/ObjectType.js

@@ -4,7 +4,8 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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 { PropertyPath, Resource } from "@rdfx/resource";
+import { PropertyPath } from "@rdfx/resource";
+import { NTriplesIdentifier } from "@rdfx/string";
 import genericToposort from "toposort";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
@@ -169,16 +170,15 @@ export class ObjectType extends AbstractType {
     toJSON() {
         return {
             ...super.toJSON(),
-            fromRdfType: this.fromRdfType.map(Resource.Identifier.toString).extract(),
+            fromRdfType: this.fromRdfType.extract(),
             identifierMintingStrategy: this.identifierMintingStrategy.extract(),
             identifierType: this.identifierType.toJSON(),
             parentObjectTypes: this.parentObjectTypes.length > 0
-                ? this.parentObjectTypes.map((parentObjectType) => parentObjectType.name.orDefault(Resource.Identifier.toString(parentObjectType.shapeIdentifier)))
+                ? this.parentObjectTypes.map((parentObjectType) => parentObjectType.name.extract() ??
+                    parentObjectType.shapeIdentifier)
                 : undefined,
             synthetic: this.synthetic ? true : undefined,
-            toRdfTypes: this.toRdfTypes.length > 0
-                ? this.toRdfTypes.map(Resource.Identifier.toString)
-                : undefined,
+            toRdfTypes: this.toRdfTypes.length > 0 ? this.toRdfTypes : undefined,
         };
     }
 }
@@ -372,7 +372,7 @@ const nodeKinds = new Set(["BlankNode", "IRI"]);
                 order: this.order,
                 path: PropertyPath.toString(this.path),
                 recursive: this.recursive ? true : undefined,
-                shapeIdentifier: Resource.Identifier.toString(this.shapeIdentifier),
+                shapeIdentifier: this.shapeIdentifier,
                 type: this.type.toJSON(),
                 visibility: this.visibility,
             };
@@ -392,18 +392,14 @@ const nodeKinds = new Set(["BlankNode", "IRI"]);
         const objectTypeGraphNodes = [];
         const objectTypeGraphEdges = [];
         for (const objectType of objectTypes) {
-            const objectTypeShapeIdentifier = Resource.Identifier.toString(objectType.shapeIdentifier);
+            const objectTypeShapeIdentifier = NTriplesIdentifier.stringify(objectType.shapeIdentifier);
             invariant(!objectTypesByShapeIdentifier[objectTypeShapeIdentifier]);
             objectTypesByShapeIdentifier[objectTypeShapeIdentifier] = objectType;
             objectTypeGraphNodes.push(objectTypeShapeIdentifier);
             for (const parentAstObjectType of objectType.parentObjectTypes) {
-                // console.log(
-                //   objectTypeShapeIdentifier,
-                //   Resource.Identifier.toString(parentAstObjectType.shapeIdentifier),
-                // );
                 objectTypeGraphEdges.push([
                     objectTypeShapeIdentifier,
-                    Resource.Identifier.toString(parentAstObjectType.shapeIdentifier),
+                    NTriplesIdentifier.stringify(parentAstObjectType.shapeIdentifier),
                 ]);
             }
         }

package/dist/ast/SetType.d.ts

@@ -21,7 +21,7 @@ export declare class SetType<ItemTypeT extends SetType.ItemType = SetType.ItemTy
         label: string | undefined;
         name: string | undefined;
         recursive: boolean | undefined;
-        shapeIdentifier: string;
+        shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
     };
 }
 export declare namespace SetType {

package/dist/ast/UnionType.d.ts

@@ -17,7 +17,7 @@ export declare class UnionType<MemberTypeT extends UnionType.MemberType = UnionT
         label: string | undefined;
         name: string | undefined;
         recursive: boolean | undefined;
-        shapeIdentifier: string;
+        shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
     };
 }
 export declare namespace UnionType {

package/dist/generators/transformAstToLabeledPropertyGraph.js

@@ -1,4 +1,3 @@
-import { Resource } from "@rdfx/resource";
 import { Maybe } from "purify-ts";
 export function transformAstToLabeledPropertyGraph(ast) {
     const nodes = [];
@@ -34,7 +33,7 @@ export function transformAstToLabeledPropertyGraph(ast) {
                 case "UnionType":
                     if (itemType.name.isJust()) {
                         relationships.push({
-                            id: Resource.Identifier.toString(namedObjectTypeProperty.shapeIdentifier),
+                            id: namedObjectTypeProperty.shapeIdentifier.toString(),
                             label: Maybe.of(namedObjectTypeProperty.name),
                             properties: {},
                             sourceNodeId: id,
@@ -68,9 +67,9 @@ export function transformAstToLabeledPropertyGraph(ast) {
     };
 }
 function typeId(type) {
-    return type.name.orDefault(Resource.Identifier.toString(type.shapeIdentifier));
+    return type.name.orDefault(type.shapeIdentifier.toString());
 }
 function typeName(type) {
-    return type.name.orDefault(Resource.Identifier.toString(type.shapeIdentifier));
+    return type.name.orDefault(type.shapeIdentifier.toString());
 }
 //# sourceMappingURL=transformAstToLabeledPropertyGraph.js.map

package/dist/generators/ts/AbstractContainerType.d.ts

@@ -38,6 +38,7 @@ export declare abstract class AbstractContainerType<ItemTypeT extends AbstractCo
     } & ConstructorParameters<typeof AbstractType>[0]);
     get recursive(): boolean;
     get schema(): Code;
+    get toRdfResourceValueTypes(): AbstractType["toRdfResourceValueTypes"];
     protected get schemaObject(): {
         item: Code;
         kind: Code;

package/dist/generators/ts/AbstractContainerType.js

@@ -31,6 +31,9 @@ export class AbstractContainerType extends AbstractType {
     get schema() {
         return code `${removeUndefined(this.schemaObject)}`;
     }
+    get toRdfResourceValueTypes() {
+        return this.itemType.toRdfResourceValueTypes;
+    }
     get schemaObject() {
         return {
             ...super.schemaObject,

package/dist/generators/ts/AbstractDateType.js

@@ -49,7 +49,7 @@ export class AbstractDateType extends AbstractPrimitiveType {
         return new AbstractPrimitiveType.JsonType(code `string`);
     }
     toRdfResourceValuesExpression({ variables, }) {
-        return code `[${snippets.literalFactory}.date(${variables.value}, ${rdfjsTermExpression(this.datatype)})]`;
+        return code `[${snippets.literalFactory}.date(${variables.value}, ${rdfjsTermExpression(this.datatype, { logger: this.logger })})]`;
     }
     fromRdfExpressionChain({ variables, }) {
         return {

package/dist/generators/ts/AbstractIdentifierType.d.ts

@@ -3,11 +3,11 @@ import type { IdentifierNodeKind } from "@shaclmate/shacl-ast";
 import { AbstractTermType } from "./AbstractTermType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare abstract class AbstractIdentifierType<IdentifierT extends BlankNode | NamedNode> extends AbstractTermType<NamedNode, IdentifierT> {
-    abstract readonly fromStringFunction: Code;
     readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
     abstract readonly kind: "BlankNodeType" | "IdentifierType" | "IriType";
     abstract readonly nodeKinds: ReadonlySet<IdentifierNodeKind>;
-    readonly toStringFunction: Code;
+    abstract readonly parseFunction: Code;
+    readonly stringifyFunction: Code;
     get conversions(): readonly AbstractTermType.Conversion[];
     graphqlResolveExpression({ variables: { value }, }: Parameters<AbstractTermType["graphqlResolveExpression"]>[0]): Code;
 }

package/dist/generators/ts/AbstractIdentifierType.js

@@ -10,10 +10,7 @@ import { imports } from "./imports.js";
 import { code } from "./ts-poet-wrapper.js";
 export class AbstractIdentifierType extends AbstractTermType {
     graphqlType = new AbstractTermType.GraphqlType(code `${imports.GraphQLString}`);
-    toStringFunction = // Re-export rdfjsResource.Resource.Identifier.toString
-     code `\
-// biome-ignore lint/suspicious/noShadowRestrictedNames: allow toString
-export const toString = ${imports.Resource}.Identifier.toString`;
+    stringifyFunction = code `${imports.NTriplesTerm}.stringify`;
     get conversions() {
         const conversions = super.conversions.concat();
         if (this.nodeKinds.has("IRI")) {
@@ -29,7 +26,7 @@ export const toString = ${imports.Resource}.Identifier.toString`;
         return conversions;
     }
     graphqlResolveExpression({ variables: { value }, }) {
-        return code `${imports.Resource}.Identifier.toString(${value})`;
+        return code `${imports.NTriplesTerm}.stringify(${value})`;
     }
 }
 __decorate([

package/dist/generators/ts/AbstractLazyObjectType.d.ts

@@ -32,6 +32,7 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
     get recursive(): boolean;
     get schema(): Code;
     get schemaType(): Code;
+    get toRdfResourceValueTypes(): AbstractType["toRdfResourceValueTypes"];
     get valueSparqlConstructTriplesFunction(): Code;
     get valueSparqlWherePatternsFunction(): Code;
     protected get schemaObject(): {
@@ -39,9 +40,9 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
         kind: Code;
     };
     hashStatements({ depth, variables, }: Parameters<AbstractType["hashStatements"]>[0]): readonly Code[];
+    jsonSchema(parameters: Parameters<AbstractType["jsonSchema"]>[0]): Code;
     jsonType(parameters?: Parameters<AbstractType["jsonType"]>[0]): AbstractType.JsonType;
     jsonUiSchemaElement(parameters: Parameters<AbstractType["jsonUiSchemaElement"]>[0]): Maybe<Code>;
-    jsonSchema(parameters: Parameters<AbstractType["jsonSchema"]>[0]): Code;
     toJsonExpression({ variables, }: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
     protected resolvedNamedObjectUnionTypeToPartialNamedObjectUnionTypeConversion({ resolvedNamedObjectUnionType, partialNamedObjectUnionType, variables, }: {

package/dist/generators/ts/AbstractLazyObjectType.js

@@ -63,6 +63,9 @@ export class AbstractLazyObjectType extends AbstractType {
             resolveType: this.resolveType.schemaType,
         }}`;
     }
+    get toRdfResourceValueTypes() {
+        return this.partialType.toRdfResourceValueTypes;
+    }
     get valueSparqlConstructTriplesFunction() {
         return code `(({ schema, ...otherParameters }) => ${this.partialType.valueSparqlConstructTriplesFunction}({ ...otherParameters, schema: schema.partial() }))`;
     }
@@ -86,15 +89,15 @@ export class AbstractLazyObjectType extends AbstractType {
             },
         });
     }
+    jsonSchema(parameters) {
+        return this.partialType.jsonSchema(parameters);
+    }
     jsonType(parameters) {
         return this.partialType.jsonType(parameters);
     }
     jsonUiSchemaElement(parameters) {
         return this.partialType.jsonUiSchemaElement(parameters);
     }
-    jsonSchema(parameters) {
-        return this.partialType.jsonSchema(parameters);
-    }
     toJsonExpression({ variables, }) {
         return this.partialType.toJsonExpression({
             variables: {

package/dist/generators/ts/AbstractNamedUnionType.js

@@ -92,7 +92,7 @@ ${this.jsonTypeAliasDeclaration}
 export namespace ${syntheticNamePrefix}Json {
   ${this.jsonSchemaFunctionDeclaration}
 
-  export function ${syntheticNamePrefix}parse(json: unknown): ${imports.Either}<Error, ${syntheticNamePrefix}Json> {
+  export function parse(json: unknown): ${imports.Either}<Error, ${syntheticNamePrefix}Json> {
     const jsonSafeParseResult = schema().safeParse(json);
     if (!jsonSafeParseResult.success) { return ${imports.Left}(jsonSafeParseResult.error); }
     return ${imports.Right}(jsonSafeParseResult.data);
@@ -107,7 +107,7 @@ export namespace ${syntheticNamePrefix}Json {
             staticModuleDeclarations[`${syntheticNamePrefix}fromRdfResourceValues`] =
                 code `export const ${syntheticNamePrefix}fromRdfResourceValues: ${snippets.FromRdfResourceValuesFunction}<${this.name}> = ${this.inlineFromRdfResourceValuesFunction};`;
             staticModuleDeclarations[`${syntheticNamePrefix}toRdfResourceValues`] =
-                code `export const ${syntheticNamePrefix}toRdfResourceValues: ${snippets.ToRdfResourceValuesFunction}<${this.name}> = ${this.inlineToRdfResourceValuesFunction};`;
+                code `export const ${syntheticNamePrefix}toRdfResourceValues = ${this.inlineToRdfResourceValuesFunction};`;
         }
         if (this.features.has("sparql")) {
             staticModuleDeclarations[`${syntheticNamePrefix}valueSparqlConstructTriples`] =

package/dist/generators/ts/AbstractNumericType.js

@@ -51,7 +51,7 @@ export class AbstractNumericType extends AbstractPrimitiveType {
         }
     }
     toRdfResourceValuesExpression({ variables, }) {
-        return code `[${snippets.literalFactory}.${this.typeofs[0]}(${variables.value}, ${rdfjsTermExpression(this.datatype)})]`;
+        return code `[${snippets.literalFactory}.${this.typeofs[0]}(${variables.value}, ${rdfjsTermExpression(this.datatype, { logger: this.logger })})]`;
     }
     fromRdfExpressionChain({ variables, }) {
         return {

package/dist/generators/ts/AbstractTermType.d.ts

@@ -32,6 +32,7 @@ export declare abstract class AbstractTermType<ConstantTermT extends Literal | N
     get discriminantProperty(): Maybe<AbstractType.DiscriminantProperty>;
     get schema(): Code;
     get termTypes(): ReadonlySet<"BlankNode" | "Literal" | "NamedNode">;
+    get toRdfResourceValueTypes(): Set<"BlankNode" | "Literal" | "NamedNode">;
     get valueSparqlConstructTriplesFunction(): Code;
     fromRdfResourceValuesExpression(parameters: Parameters<AbstractType["fromRdfResourceValuesExpression"]>[0]): Code;
     hashStatements({ variables, }: Parameters<AbstractType["hashStatements"]>[0]): readonly Code[];

package/dist/generators/ts/AbstractTermType.js

@@ -93,6 +93,9 @@ export class AbstractTermType extends AbstractType {
     get termTypes() {
         return new Set([...this.nodeKinds].map(NodeKind.toTermType));
     }
+    get toRdfResourceValueTypes() {
+        return new Set([...this.nodeKinds].map(NodeKind.toTermType));
+    }
     get valueSparqlConstructTriplesFunction() {
         return code `((_: object) => [])`;
     }
@@ -136,7 +139,7 @@ export class AbstractTermType extends AbstractType {
     fromRdfExpressionChain({ variables, }) {
         let valueToExpression;
         if (this.in_.length > 0) {
-            valueToExpression = code `value.toTerm([${joinCode(this.in_.map((in_) => rdfjsTermExpression(in_)), { on: ", " })}])`;
+            valueToExpression = code `value.toTerm([${joinCode(this.in_.map((in_) => rdfjsTermExpression(in_, { logger: this.logger })), { on: ", " })}])`;
         }
         else if (this.nodeKinds.size < 3) {
             const eitherTypeParameters = code `<Error, ${this.name}>`;
@@ -152,7 +155,7 @@ export class AbstractTermType extends AbstractType {
         return {
             hasValues: this.hasValues.length > 0
                 ? code `\
-chain(values => ${imports.Either}.sequence([${joinCode(this.hasValues.map(rdfjsTermExpression), { on: ", " })}].map(hasValue => values.find(value => value.term.equals(hasValue)))).map(() => values))`
+chain(values => ${imports.Either}.sequence([${joinCode(this.hasValues.map((hasValue) => rdfjsTermExpression(hasValue, { logger: this.logger })), { on: ", " })}].map(hasValue => values.find(value => value.term.equals(hasValue)))).map(() => values))`
                 : undefined,
             valueTo: code `chain(values => values.chainMap(value => ${valueToExpression}))`,
         };
@@ -170,6 +173,9 @@ __decorate([
 __decorate([
     Memoize()
 ], AbstractTermType.prototype, "termTypes", null);
+__decorate([
+    Memoize()
+], AbstractTermType.prototype, "toRdfResourceValueTypes", null);
 __decorate([
     Memoize()
 ], AbstractTermType.prototype, "valueSparqlConstructTriplesFunction", null);

package/dist/generators/ts/AbstractType.d.ts

@@ -1,10 +1,12 @@
 import type { Maybe, NonEmptyList } from "purify-ts";
+import type { Logger } from "ts-log";
 import type { Typeof } from "./Typeof.js";
 import { type Code } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class all types.
  */
 export declare abstract class AbstractType {
+    protected readonly logger: Logger;
     /**
      * Is the type abstract?
      */
@@ -104,9 +106,10 @@ export declare abstract class AbstractType {
      * - variablePrefix: string prefix to use for new variables
      */
     abstract readonly valueSparqlWherePatternsFunction: Code;
-    constructor({ comment, label, }: {
+    constructor({ comment, label, logger, }: {
         comment: Maybe<string>;
         label: Maybe<string>;
+        logger: Logger;
     });
     /**
      * Helper to compose the result of schema along the type hierarchy.
@@ -177,6 +180,19 @@ export declare abstract class AbstractType {
             value: Code;
         };
     }): readonly Code[];
+    /**
+     * Zod schema for the JSON type of this type.
+     *
+     * This method is called in two contexts:
+     * "property": from a ShaclProperty, while generating the z.object properties of an NamedObjectType
+     * "type": from another Type e.g., an OptionType or UnionType
+     *
+     * z.lazy() should only be returned for "property".
+     */
+    abstract jsonSchema(parameters: {
+        includeDiscriminantProperty?: boolean;
+        context: "property" | "type";
+    }): Code;
     /**
      * JSON-compatible version of the type.
      */
@@ -191,19 +207,6 @@ export declare abstract class AbstractType {
             scopePrefix: Code;
         };
     }): Maybe<Code>;
-    /**
-     * Zod schema for the JSON type of this type.
-     *
-     * This method is called in two contexts:
-     * "property": from a ShaclProperty, while generating the z.object properties of an NamedObjectType
-     * "type": from another Type e.g., an OptionType or UnionType
-     *
-     * z.lazy() should only be returned for "property".
-     */
-    abstract jsonSchema(parameters: {
-        includeDiscriminantProperty?: boolean;
-        context: "property" | "type";
-    }): Code;
     /**
      * An expression that converts a value of this type to a JSON-LD compatible value. It can assume the presence
      * of the correct JSON-LD context.
@@ -214,6 +217,10 @@ export declare abstract class AbstractType {
             value: Code;
         };
     }): Code;
+    /**
+     * The type(s) of the array elements produced by the toRdfResourceValuesExpression.
+     */
+    abstract readonly toRdfResourceValueTypes: ReadonlySet<"BlankNode" | "NamedNode" | "Literal">;
     /**
      * An expression that converts a property value of this type to a value or an array of values that can be .add'd to a Resource with
      *   resource.add(predicate, convertedValue, graph)

package/dist/generators/ts/AbstractType.js

@@ -12,6 +12,7 @@ import { code, literalOf } from "./ts-poet-wrapper.js";
  * Abstract base class all types.
  */
 export class AbstractType {
+    logger;
     /**
      * Comment from rdfs:comment.
      */
@@ -20,9 +21,10 @@ export class AbstractType {
      * Label from rdfs:label.
      */
     label;
-    constructor({ comment, label, }) {
+    constructor({ comment, label, logger, }) {
         this.comment = comment;
         this.label = label;
+        this.logger = logger;
     }
     /**
      * Helper to compose the result of schema along the type hierarchy.

package/dist/generators/ts/AbstractUnionType.d.ts

@@ -10,7 +10,6 @@ export declare abstract class AbstractUnionType<MemberTypeT extends Type> extend
     private readonly discriminant;
     private readonly identifierType;
     readonly abstract = false;
-    private readonly lazyMembers;
     readonly recursive: boolean;
     constructor({ identifierType, members, recursive, ...superParameters }: {
         identifierType: Maybe<BlankNodeType | IdentifierType | IriType>;
@@ -25,6 +24,7 @@ export declare abstract class AbstractUnionType<MemberTypeT extends Type> extend
     get mutable(): boolean;
     get schema(): Code;
     get schemaType(): Code;
+    get toRdfResourceValueTypes(): AbstractType["toRdfResourceValueTypes"];
     get typeofs(): AbstractType["typeofs"];
     protected get concreteMembers(): readonly AbstractUnionType.ConcreteMember<MemberTypeT>[];
     protected get inlineEqualsFunction(): Code;
@@ -32,19 +32,20 @@ export declare abstract class AbstractUnionType<MemberTypeT extends Type> extend
     protected get inlineFilterType(): Code;
     protected get inlineFromJsonFunction(): Code;
     protected get inlineFromRdfResourceValuesFunction(): Code;
-    protected get inlineJsonType(): AbstractType.JsonType;
     protected get inlineJsonSchema(): Code;
+    protected get inlineJsonType(): AbstractType.JsonType;
     protected get inlineName(): Code;
-    protected get inlineValueSparqlConstructTriplesFunction(): Code;
-    protected get inlineValueSparqlWherePatternsFunction(): Code;
     protected get inlineToJsonFunction(): Code;
     protected get inlineToRdfResourceValuesFunction(): Code;
+    protected get inlineValueSparqlConstructTriplesFunction(): Code;
+    protected get inlineValueSparqlWherePatternsFunction(): Code;
     protected get schemaObject(): {
         kind: Code;
         members: Code;
     };
     jsonUiSchemaElement(): Maybe<Code>;
     protected inlineHashStatements({ depth, variables, }: Parameters<AbstractType["hashStatements"]>[0]): readonly Code[];
+    private readonly lazyMembers;
 }
 type Discriminant = ExtrinsicDiscriminant | HybridDiscriminant | IntrinsicDiscriminant | TypeofDiscriminant;
 type ExtrinsicDiscriminant = {