@shaclmate/compiler 4.0.8 → 4.0.9

package/dist/generators/ts/AbstractIdentifierType.js

@@ -4,10 +4,10 @@ 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 { code } from "ts-poet";
 import { Memoize } from "typescript-memoize";
 import { AbstractTermType } from "./AbstractTermType.js";
 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

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

@@ -1,7 +1,7 @@
 import { Maybe, NonEmptyList } from "purify-ts";
 import { AbstractType } from "./AbstractType.js";
+import type { NamedObjectUnionType } from "./NamedObjectUnionType.js";
 import type { ObjectType } from "./ObjectType.js";
-import type { ObjectUnionType } from "./ObjectUnionType.js";
 import type { OptionType } from "./OptionType.js";
 import type { SetType } from "./SetType.js";
 import { type Code } from "./ts-poet-wrapper.js";
@@ -13,6 +13,8 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
         readonly partialPropertyName: string;
         readonly rawName: Code;
     };
+    readonly abstract = false;
+    readonly declaration: Maybe<Code>;
     readonly discriminantProperty: AbstractType["discriminantProperty"];
     readonly mutable = false;
     readonly typeofs: NonEmptyList<"object">;
@@ -27,10 +29,11 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
     get filterType(): Code;
     get graphqlType(): AbstractType.GraphqlType;
     get name(): Code;
+    get recursive(): boolean;
     get schema(): Code;
     get schemaType(): Code;
-    get sparqlConstructTriplesFunction(): Code;
-    get sparqlWherePatternsFunction(): Code;
+    get valueSparqlConstructTriplesFunction(): Code;
+    get valueSparqlWherePatternsFunction(): Code;
     protected get schemaObject(): {
         partial: Code;
         kind: Code;
@@ -40,17 +43,17 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
     jsonUiSchemaElement(parameters: Parameters<AbstractType["jsonUiSchemaElement"]>[0]): Maybe<Code>;
     jsonZodSchema(parameters: Parameters<AbstractType["jsonZodSchema"]>[0]): Code;
     toJsonExpression({ variables, }: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
-    toRdfExpression({ variables, }: Parameters<AbstractType["toRdfExpression"]>[0]): Code;
-    protected resolvedObjectUnionTypeToPartialObjectUnionTypeConversion({ resolvedObjectUnionType, partialObjectUnionType, variables, }: {
-        resolvedObjectUnionType: ObjectUnionType;
-        partialObjectUnionType: ObjectUnionType;
+    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
+    protected resolvedNamedObjectUnionTypeToPartialNamedObjectUnionTypeConversion({ resolvedNamedObjectUnionType, partialNamedObjectUnionType, variables, }: {
+        resolvedNamedObjectUnionType: NamedObjectUnionType;
+        partialNamedObjectUnionType: NamedObjectUnionType;
         variables: {
             resolvedObjectUnion: Code;
         };
     }): Code;
 }
 export declare namespace AbstractLazyObjectType {
-    type ObjectTypeConstraint = ObjectType | ObjectUnionType;
+    type ObjectTypeConstraint = ObjectType | NamedObjectUnionType;
     type PartialTypeConstraint = ObjectTypeConstraint | OptionType<ObjectTypeConstraint> | SetType<ObjectTypeConstraint>;
     type ResolveTypeConstraint = PartialTypeConstraint;
     type Conversion = AbstractType.Conversion;

package/dist/generators/ts/AbstractLazyObjectType.js

@@ -14,6 +14,8 @@ export class AbstractLazyObjectType extends AbstractType {
     partialType;
     resolveType;
     runtimeClass;
+    abstract = false;
+    declaration = Maybe.empty();
     discriminantProperty = Maybe.empty();
     mutable = false;
     typeofs = NonEmptyList(["object"]);
@@ -48,6 +50,9 @@ export class AbstractLazyObjectType extends AbstractType {
     get name() {
         return this.runtimeClass.name;
     }
+    get recursive() {
+        return this.partialType.recursive;
+    }
     get schema() {
         return code `${removeUndefined(this.schemaObject)}`;
     }
@@ -58,11 +63,11 @@ export class AbstractLazyObjectType extends AbstractType {
             resolveType: this.resolveType.schemaType,
         }}`;
     }
-    get sparqlConstructTriplesFunction() {
-        return code `(({ schema, ...otherParameters }) => ${this.partialType.sparqlConstructTriplesFunction}({ ...otherParameters, schema: schema.partial() }))`;
+    get valueSparqlConstructTriplesFunction() {
+        return code `(({ schema, ...otherParameters }) => ${this.partialType.valueSparqlConstructTriplesFunction}({ ...otherParameters, schema: schema.partial() }))`;
     }
-    get sparqlWherePatternsFunction() {
-        return code `(({ schema, ...otherParameters }) => ${this.partialType.sparqlWherePatternsFunction}({ ...otherParameters, schema: schema.partial() }))`;
+    get valueSparqlWherePatternsFunction() {
+        return code `(({ schema, ...otherParameters }) => ${this.partialType.valueSparqlWherePatternsFunction}({ ...otherParameters, schema: schema.partial() }))`;
     }
     get schemaObject() {
         return {
@@ -97,22 +102,22 @@ export class AbstractLazyObjectType extends AbstractType {
             },
         });
     }
-    toRdfExpression({ variables, }) {
-        return this.partialType.toRdfExpression({
+    toRdfResourceValuesExpression({ variables, }) {
+        return this.partialType.toRdfResourceValuesExpression({
             variables: {
                 ...variables,
                 value: code `${variables.value}.${this.runtimeClass.partialPropertyName}`,
             },
         });
     }
-    resolvedObjectUnionTypeToPartialObjectUnionTypeConversion({ resolvedObjectUnionType, partialObjectUnionType, variables, }) {
-        invariant(resolvedObjectUnionType.memberTypes.length ===
-            partialObjectUnionType.memberTypes.length);
-        const caseBlocks = resolvedObjectUnionType.memberTypes.map((resolvedObjectType, objectTypeI) => {
-            return code `${resolvedObjectType.discriminantPropertyValues.map((discriminantPropertyValue) => `case "${discriminantPropertyValue}":`).join("\n")} return ${partialObjectUnionType.memberTypes[objectTypeI].newExpression({ parameters: variables.resolvedObjectUnion })};`;
+    resolvedNamedObjectUnionTypeToPartialNamedObjectUnionTypeConversion({ resolvedNamedObjectUnionType, partialNamedObjectUnionType, variables, }) {
+        invariant(resolvedNamedObjectUnionType.members.length ===
+            partialNamedObjectUnionType.members.length);
+        const caseBlocks = resolvedNamedObjectUnionType.members.map(({ discriminantValues }, memberI) => {
+            return code `${discriminantValues.map((discriminantPropertyValue) => `case "${discriminantPropertyValue}":`).join("\n")} return ${partialNamedObjectUnionType.members[memberI].type.newExpression({ parameters: variables.resolvedObjectUnion })};`;
         });
         caseBlocks.push(code `default: ${variables.resolvedObjectUnion} satisfies never; throw new Error("unrecognized type");`);
-        return code `switch (${variables.resolvedObjectUnion}.${resolvedObjectUnionType.discriminantProperty.unsafeCoerce().name}) { ${joinCode(caseBlocks)} }`;
+        return code `switch (${variables.resolvedObjectUnion}.${resolvedNamedObjectUnionType.discriminantProperty.unsafeCoerce().name}) { ${joinCode(caseBlocks)} }`;
     }
 }
 __decorate([
@@ -129,10 +134,10 @@ __decorate([
 ], AbstractLazyObjectType.prototype, "schemaType", null);
 __decorate([
     Memoize()
-], AbstractLazyObjectType.prototype, "sparqlConstructTriplesFunction", null);
+], AbstractLazyObjectType.prototype, "valueSparqlConstructTriplesFunction", null);
 __decorate([
     Memoize()
-], AbstractLazyObjectType.prototype, "sparqlWherePatternsFunction", null);
+], AbstractLazyObjectType.prototype, "valueSparqlWherePatternsFunction", null);
 (function (AbstractLazyObjectType) {
     AbstractLazyObjectType.GraphqlType = AbstractType.GraphqlType;
     AbstractLazyObjectType.JsonType = AbstractType.JsonType;

package/dist/generators/ts/AbstractNamedUnionType.d.ts

@@ -0,0 +1,33 @@
+import { Maybe } from "purify-ts";
+import type { TsFeature } from "../../enums/TsFeature.js";
+import { AbstractType } from "./AbstractType.js";
+import { AbstractUnionType } from "./AbstractUnionType.js";
+import type { Type } from "./Type.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare abstract class AbstractNamedUnionType<MemberTypeT extends Type> extends AbstractUnionType<MemberTypeT> {
+    protected readonly _name: string;
+    readonly features: ReadonlySet<TsFeature>;
+    constructor({ features, name, ...superParameters }: {
+        features: ReadonlySet<TsFeature>;
+        name: string;
+    } & ConstructorParameters<typeof AbstractUnionType<MemberTypeT>>[0]);
+    get declaration(): Maybe<Code>;
+    get equalsFunction(): Code;
+    get filterFunction(): Code;
+    get filterType(): Code;
+    get jsonTypeAliasDeclaration(): Code;
+    get jsonZodSchemaFunctionDeclaration(): Code;
+    get name(): string;
+    get staticModuleName(): string;
+    get valueSparqlConstructTriplesFunction(): Code;
+    get valueSparqlWherePatternsFunction(): Code;
+    protected get staticModuleDeclarations(): Record<string, Code>;
+    fromJsonExpression({ variables, }: Parameters<AbstractType["fromJsonExpression"]>[0]): Code;
+    fromRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["fromRdfResourceValuesExpression"]>[0]): Code;
+    hashStatements({ depth, variables, }: Parameters<AbstractType["hashStatements"]>[0]): readonly Code[];
+    jsonType(): AbstractType.JsonType;
+    jsonZodSchema({ context, }: Parameters<AbstractType["jsonZodSchema"]>[0]): Code;
+    toJsonExpression({ variables, }: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
+    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
+}
+//# sourceMappingURL=AbstractNamedUnionType.d.ts.map

package/dist/generators/ts/AbstractNamedUnionType.js

@@ -0,0 +1,193 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Maybe } from "purify-ts";
+import { Memoize } from "typescript-memoize";
+import { AbstractType } from "./AbstractType.js";
+import { AbstractUnionType } from "./AbstractUnionType.js";
+import { imports } from "./imports.js";
+import { snippets } from "./snippets.js";
+import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
+import { code, def, joinCode } from "./ts-poet-wrapper.js";
+export class AbstractNamedUnionType extends AbstractUnionType {
+    _name;
+    features;
+    constructor({ features, name, ...superParameters }) {
+        super(superParameters);
+        this.features = features;
+        this._name = name;
+    }
+    get declaration() {
+        const declarations = [
+            code `export type ${def(this._name)} = ${this.inlineName};`,
+        ];
+        const staticModuleDeclarations = Object.entries(this.staticModuleDeclarations);
+        if (staticModuleDeclarations.length > 0) {
+            declarations.push(code `\
+export namespace ${def(this.staticModuleName)} {
+${joinCode(staticModuleDeclarations
+                .sort((left, right) => left[0].localeCompare(right[0]))
+                .map((_) => _[1]), { on: "\n\n" })}
+}`);
+        }
+        return Maybe.of(joinCode(declarations, { on: "\n\n" }));
+    }
+    get equalsFunction() {
+        if (this.features.has("equals")) {
+            return code `${this.staticModuleName}.${syntheticNamePrefix}equals`;
+        }
+        return this.inlineEqualsFunction;
+    }
+    get filterFunction() {
+        return code `${this.staticModuleName}.${syntheticNamePrefix}filter`;
+    }
+    get filterType() {
+        return code `${this.staticModuleName}.${syntheticNamePrefix}Filter`;
+    }
+    get jsonTypeAliasDeclaration() {
+        return code `export type ${syntheticNamePrefix}Json = ${this.inlineJsonType.name}`;
+    }
+    get jsonZodSchemaFunctionDeclaration() {
+        return code `export const ${syntheticNamePrefix}jsonZodSchema = () => ${this.inlineJsonZodSchema};`;
+    }
+    get name() {
+        return this._name;
+    }
+    get staticModuleName() {
+        return this._name;
+    }
+    get valueSparqlConstructTriplesFunction() {
+        if (this.features.has("sparql")) {
+            return code `${this.staticModuleName}.${syntheticNamePrefix}valueSparqlConstructTriples`;
+        }
+        return this.inlineValueSparqlConstructTriplesFunction;
+    }
+    get valueSparqlWherePatternsFunction() {
+        if (this.features.has("sparql")) {
+            return code `${this.staticModuleName}.${syntheticNamePrefix}valueSparqlWherePatterns`;
+        }
+        return this.inlineValueSparqlWherePatternsFunction;
+    }
+    get staticModuleDeclarations() {
+        const staticModuleDeclarations = {};
+        if (this.features.has("equals")) {
+            staticModuleDeclarations[`${syntheticNamePrefix}equals`] =
+                code `export const ${syntheticNamePrefix}equals = ${this.inlineEqualsFunction};`;
+        }
+        staticModuleDeclarations[`${syntheticNamePrefix}Filter`] =
+            code `export type ${syntheticNamePrefix}Filter = ${this.inlineFilterType};`;
+        staticModuleDeclarations[`${syntheticNamePrefix}filter`] =
+            code `export const ${syntheticNamePrefix}filter = ${this.inlineFilterFunction};`;
+        if (this.features.has("hash")) {
+            staticModuleDeclarations[`${syntheticNamePrefix}hash`] =
+                code `export function ${syntheticNamePrefix}hash<HasherT extends ${snippets.Hasher}>(value: ${this._name}, hasher: HasherT): HasherT { ${this.inlineHashStatements({ depth: 0, variables: { hasher: code `hasher`, value: code `value` } })} return hasher; }`;
+        }
+        if (this.features.has("json")) {
+            staticModuleDeclarations[`${syntheticNamePrefix}Json`] =
+                this.jsonTypeAliasDeclaration;
+            staticModuleDeclarations[`${syntheticNamePrefix}fromJson`] =
+                code `export const ${syntheticNamePrefix}fromJson = ${this.inlineFromJsonFunction};`;
+            staticModuleDeclarations[`${syntheticNamePrefix}jsonZodSchema`] =
+                this.jsonZodSchemaFunctionDeclaration;
+            staticModuleDeclarations[`${syntheticNamePrefix}parseJson`] = code `\
+export function ${syntheticNamePrefix}parseJson(json: unknown): ${imports.Either}<Error, ${this.name}> {
+  const ${syntheticNamePrefix}jsonSafeParseResult = ${syntheticNamePrefix}jsonZodSchema().safeParse(json);
+  if (!${syntheticNamePrefix}jsonSafeParseResult.success) { return ${imports.Left}(${syntheticNamePrefix}jsonSafeParseResult.error); }
+  return ${imports.Right}(${syntheticNamePrefix}fromJson(${syntheticNamePrefix}jsonSafeParseResult.data));
+}`;
+            staticModuleDeclarations[`${syntheticNamePrefix}toJson`] =
+                code `export const ${syntheticNamePrefix}toJson = ${this.inlineToJsonFunction};`;
+        }
+        if (this.features.has("rdf")) {
+            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};`;
+        }
+        if (this.features.has("sparql")) {
+            staticModuleDeclarations[`${syntheticNamePrefix}valueSparqlConstructTriples`] =
+                code `export const ${syntheticNamePrefix}valueSparqlConstructTriples: ${snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}> = ${this.inlineValueSparqlConstructTriplesFunction};`;
+            staticModuleDeclarations[`${syntheticNamePrefix}valueSparqlWherePatterns`] =
+                code `export const ${syntheticNamePrefix}valueSparqlWherePatterns: ${snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}> = ${this.inlineValueSparqlWherePatternsFunction};`;
+        }
+        return staticModuleDeclarations;
+    }
+    fromJsonExpression({ variables, }) {
+        if (this.features.has("json")) {
+            return code `${this.staticModuleName}.${syntheticNamePrefix}fromJson(${variables.value})`;
+        }
+        return code `${this.inlineFromJsonFunction}(${variables.value})`;
+    }
+    fromRdfResourceValuesExpression({ variables, }) {
+        const { resourceValues: resourceValuesVariable, ...otherVariables } = variables;
+        if (this.features.has("rdf")) {
+            return code `${this.staticModuleName}.${syntheticNamePrefix}fromRdfResourceValues(${resourceValuesVariable}, ${otherVariables})`;
+        }
+        return code `${this.inlineFromRdfResourceValuesFunction}(${resourceValuesVariable}, ${otherVariables})`;
+    }
+    hashStatements({ depth, variables, }) {
+        if (this.features.has("hash")) {
+            return [
+                code `${this.staticModuleName}.${syntheticNamePrefix}hash(${variables.value}, ${variables.hasher});`,
+            ];
+        }
+        return this.inlineHashStatements({ depth, variables });
+    }
+    jsonType() {
+        if (this.features.has("json")) {
+            return new AbstractType.JsonType(`${this.staticModuleName}.${syntheticNamePrefix}Json`);
+        }
+        return this.inlineJsonType;
+    }
+    jsonZodSchema({ context, }) {
+        if (this.features.has("json")) {
+            const expression = code `${this.staticModuleName}.${syntheticNamePrefix}jsonZodSchema()`;
+            if (context === "property" && this.recursive) {
+                return code `${imports.z}.lazy((): ${imports.z}.ZodType<${this.staticModuleName}.${syntheticNamePrefix}Json> => ${expression})`;
+            }
+            return expression;
+        }
+        return this.inlineJsonZodSchema;
+    }
+    toJsonExpression({ variables, }) {
+        if (this.features.has("json")) {
+            return code `${this.staticModuleName}.${syntheticNamePrefix}toJson(${variables.value})`;
+        }
+        return code `${this.inlineToJsonFunction}(${variables.value})`;
+    }
+    toRdfResourceValuesExpression({ variables, }) {
+        const { value: valueVariable, ...otherVariables } = variables;
+        if (this.features.has("rdf")) {
+            return code `${this.staticModuleName}.${syntheticNamePrefix}toRdfResourceValues(${valueVariable}, ${otherVariables})`;
+        }
+        return code `${this.inlineToRdfResourceValuesFunction}(${valueVariable}, ${otherVariables})`;
+    }
+}
+__decorate([
+    Memoize()
+], AbstractNamedUnionType.prototype, "declaration", null);
+__decorate([
+    Memoize()
+], AbstractNamedUnionType.prototype, "equalsFunction", null);
+__decorate([
+    Memoize()
+], AbstractNamedUnionType.prototype, "filterFunction", null);
+__decorate([
+    Memoize()
+], AbstractNamedUnionType.prototype, "filterType", null);
+__decorate([
+    Memoize()
+], AbstractNamedUnionType.prototype, "name", null);
+__decorate([
+    Memoize()
+], AbstractNamedUnionType.prototype, "valueSparqlConstructTriplesFunction", null);
+__decorate([
+    Memoize()
+], AbstractNamedUnionType.prototype, "valueSparqlWherePatternsFunction", null);
+__decorate([
+    Memoize()
+], AbstractNamedUnionType.prototype, "jsonType", null);
+//# sourceMappingURL=AbstractNamedUnionType.js.map

package/dist/generators/ts/AbstractNumericType.d.ts

@@ -9,14 +9,14 @@ export declare abstract class AbstractNumericType<ValueT extends bigint | number
     get filterType(): Code;
     get name(): string;
     get schemaType(): Code;
-    get sparqlWherePatternsFunction(): Code;
+    get valueSparqlWherePatternsFunction(): Code;
     protected get schemaObject(): {
         in: Code[] | undefined;
         languageIn: import("ts-poet/build/Node.js").Node[] | undefined;
         kind: Code;
     };
     jsonZodSchema(_parameters: Parameters<AbstractPrimitiveType<ValueT>["jsonZodSchema"]>[0]): Code;
-    toRdfExpression({ variables, }: Parameters<AbstractPrimitiveType<string>["toRdfExpression"]>[0]): Code;
+    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<string>["toRdfResourceValuesExpression"]>[0]): Code;
     protected fromRdfExpressionChain({ variables, }: Parameters<AbstractPrimitiveType<ValueT>["fromRdfExpressionChain"]>[0]): ReturnType<AbstractPrimitiveType<ValueT>["fromRdfExpressionChain"]>;
     protected abstract fromRdfResourceValueExpression(variables: {
         variables: {

package/dist/generators/ts/AbstractNumericType.js

@@ -29,7 +29,7 @@ export class AbstractNumericType extends AbstractPrimitiveType {
     get schemaType() {
         return code `${snippets.NumericSchema}<${this.typeofs[0]}>`;
     }
-    get sparqlWherePatternsFunction() {
+    get valueSparqlWherePatternsFunction() {
         return code `${snippets.numericSparqlWherePatterns}<${this.typeofs[0]}>`;
     }
     get schemaObject() {
@@ -50,7 +50,7 @@ export class AbstractNumericType extends AbstractPrimitiveType {
                 return code `${imports.z}.union([${joinCode(this.primitiveIn.map((value) => code `${imports.z}.literal(${this.literalOf(value)})`), { on: "," })}])`;
         }
     }
-    toRdfExpression({ variables, }) {
+    toRdfResourceValuesExpression({ variables, }) {
         return code `[${snippets.literalFactory}.${this.typeofs[0]}(${variables.value}, ${rdfjsTermExpression(this.datatype)})]`;
     }
     fromRdfExpressionChain({ variables, }) {
@@ -78,7 +78,7 @@ __decorate([
 ], AbstractNumericType.prototype, "schemaType", null);
 __decorate([
     Memoize()
-], AbstractNumericType.prototype, "sparqlWherePatternsFunction", null);
+], AbstractNumericType.prototype, "valueSparqlWherePatternsFunction", null);
 (function (AbstractNumericType) {
     AbstractNumericType.JsonType = AbstractPrimitiveType.JsonType;
 })(AbstractNumericType || (AbstractNumericType = {}));

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

@@ -13,12 +13,15 @@ import { type Code } from "./ts-poet-wrapper.js";
  * The two are differentiated because identifiers can have BlankNode or NamedNode values at runtime but only NamedNode values for sh:hasValue and sh:in.
  */
 export declare abstract class AbstractTermType<ConstantTermT extends Literal | NamedNode = Literal | NamedNode, _RuntimeTermT extends BlankNode | Literal | NamedNode = BlankNode | Literal | NamedNode> extends AbstractType {
+    readonly abstract = false;
+    readonly declaration: Maybe<Code>;
     readonly equalsFunction: Code;
     readonly graphqlArgs: AbstractType["graphqlArgs"];
     readonly hasValues: readonly ConstantTermT[];
     readonly in_: readonly ConstantTermT[];
     readonly mutable: boolean;
     abstract readonly nodeKinds: ReadonlySet<NodeKind>;
+    readonly recursive = false;
     readonly typeofs: AbstractType["typeofs"];
     constructor({ hasValues, in_, ...superParameters }: {
         hasValues: readonly ConstantTermT[];
@@ -28,11 +31,11 @@ export declare abstract class AbstractTermType<ConstantTermT extends Literal | N
     get conversions(): readonly AbstractType.Conversion[];
     get discriminantProperty(): Maybe<AbstractType.DiscriminantProperty>;
     get schema(): Code;
-    get sparqlConstructTriplesFunction(): Code;
-    fromRdfExpression(parameters: Parameters<AbstractType["fromRdfExpression"]>[0]): Code;
+    get valueSparqlConstructTriplesFunction(): Code;
+    fromRdfResourceValuesExpression(parameters: Parameters<AbstractType["fromRdfResourceValuesExpression"]>[0]): Code;
     hashStatements({ variables, }: Parameters<AbstractType["hashStatements"]>[0]): readonly Code[];
     jsonUiSchemaElement(): Maybe<Code>;
-    toRdfExpression({ variables, }: Parameters<AbstractType["toRdfExpression"]>[0]): Code;
+    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
     /**
      * The fromRdfExpression for a term type can be decomposed into multiple sub-expressions with different purposes:
      *
@@ -42,7 +45,7 @@ export declare abstract class AbstractTermType<ConstantTermT extends Literal | N
      *
      * Considering the sub-expressions as a record instead of an array allows them to be selectively overridden by subclasses.
      */
-    protected fromRdfExpressionChain({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): {
+    protected fromRdfExpressionChain({ variables, }: Parameters<Type["fromRdfResourceValuesExpression"]>[0]): {
         hasValues?: Code;
         languageIn?: Code;
         preferredLanguages?: Code;

package/dist/generators/ts/AbstractTermType.js

@@ -22,11 +22,14 @@ import { code, joinCode } from "./ts-poet-wrapper.js";
  * The two are differentiated because identifiers can have BlankNode or NamedNode values at runtime but only NamedNode values for sh:hasValue and sh:in.
  */
 export class AbstractTermType extends AbstractType {
+    abstract = false;
+    declaration = Maybe.empty();
     equalsFunction = code `${snippets.booleanEquals}`;
     graphqlArgs = Maybe.empty();
     hasValues;
     in_;
     mutable = false;
+    recursive = false;
     typeofs = NonEmptyList([
         "object",
     ]);
@@ -87,10 +90,10 @@ export class AbstractTermType extends AbstractType {
     get schema() {
         return code `${removeUndefined(this.schemaObject)}`;
     }
-    get sparqlConstructTriplesFunction() {
+    get valueSparqlConstructTriplesFunction() {
         return code `((_: object) => [])`;
     }
-    fromRdfExpression(parameters) {
+    fromRdfResourceValuesExpression(parameters) {
         // invariant(
         //   this.nodeKinds.has("Literal") &&
         //     (this.nodeKinds.has("BlankNode") || this.nodeKinds.has("NamedNode")),
@@ -115,7 +118,7 @@ export class AbstractTermType extends AbstractType {
     jsonUiSchemaElement() {
         return Maybe.empty();
     }
-    toRdfExpression({ variables, }) {
+    toRdfResourceValuesExpression({ variables, }) {
         return code `[${variables.value}]`;
     }
     /**
@@ -163,7 +166,7 @@ __decorate([
 ], AbstractTermType.prototype, "schema", null);
 __decorate([
     Memoize()
-], AbstractTermType.prototype, "sparqlConstructTriplesFunction", null);
+], AbstractTermType.prototype, "valueSparqlConstructTriplesFunction", null);
 (function (AbstractTermType) {
     AbstractTermType.GraphqlType = AbstractType.GraphqlType;
     AbstractTermType.JsonType = AbstractType.JsonType;

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

@@ -5,6 +5,10 @@ import { type Code } from "./ts-poet-wrapper.js";
  * Abstract base class all types.
  */
 export declare abstract class AbstractType {
+    /**
+     * Is the type abstract?
+     */
+    abstract readonly abstract: boolean;
     /**
      * Comment from rdfs:comment.
      */
@@ -13,6 +17,10 @@ export declare abstract class AbstractType {
      * Expressions that convert a source type or types to this type. It should include the type itself.
      */
     abstract readonly conversions: readonly AbstractType.Conversion[];
+    /**
+     * The declaration of named types.
+     */
+    abstract readonly declaration: Maybe<Code>;
     /**
      * A property that discriminates sub-types of this type e.g., termType on RDF/JS terms.
      */
@@ -57,6 +65,10 @@ export declare abstract class AbstractType {
      * TypeScript name of the type.
      */
     abstract readonly name: Code | string;
+    /**
+     * Does this type directly or indirectly reference itself?
+     */
+    abstract readonly recursive: boolean;
     /**
      * TypeScript object describing this type, for runtime use.
      */
@@ -66,20 +78,24 @@ export declare abstract class AbstractType {
      */
     abstract readonly schemaType: Code;
     /**
-     * A SparqlConstructTriplesFunction (reference or declaration) that returns an array of sparqljs.Triple's for a property of this type.
+     * JavaScript typeof(s) the type.
+     */
+    abstract readonly typeofs: NonEmptyList<Typeof>;
+    /**
+     * A ValueSparqlConstructTriplesFunction (reference or declaration) that returns an array of sparqljs.Triple's for a property value of this type.
      *
-     * The function takes a parameters object (type: SparqlConstructTriplesFunctionParameters) with the following parameters:
+     * The function takes a parameters object with the following parameters:
      * - filter: an instance of filterType | undefined
      * - ignoreRdfType: boolean
      * - schema: instance of this.schemaType
      * - valueVariable: rdfjs.Variable of the value of this type
      * - variablePrefix: string prefix to use for new variables
      */
-    abstract readonly sparqlConstructTriplesFunction: Code;
+    abstract readonly valueSparqlConstructTriplesFunction: Code;
     /**
-     * A SparqlWherePatternsFunction (reference or declaration) that returns an array of SparqlPattern's for a property of this type.
+     * A ValueSparqlWherePatternsFunction (reference or declaration) that returns an array of SparqlPattern's for a property value of this type.
      *
-     * The function takes a parameters object (type: SparqlWherePatternsFunctionParameters) with the following parameters:
+     * The function takes a parameters object with the following parameters:
      * - filter: an instance of filterType | undefined
      * - preferredLanguages: array of preferred language code (strings) | undefined
      * - propertyPatterns: array of sparqljs.Pattern's for the property; may be empty
@@ -87,11 +103,7 @@ export declare abstract class AbstractType {
      * - valueVariable: rdfjs.Variable of the value of this type
      * - variablePrefix: string prefix to use for new variables
      */
-    abstract readonly sparqlWherePatternsFunction: Code;
-    /**
-     * JavaScript typeof(s) the type.
-     */
-    abstract readonly typeofs: NonEmptyList<Typeof>;
+    abstract readonly valueSparqlWherePatternsFunction: Code;
     constructor({ comment, label, }: {
         comment: Maybe<string>;
         label: Maybe<string>;
@@ -134,7 +146,7 @@ export declare abstract class AbstractType {
      *   resource: the Resource passed to Object.fromRdf
      *   resourceValues: the Either<Error, rdfjsResource.Resource.Values> to be converted to values of this type
      */
-    abstract fromRdfExpression(parameters: {
+    abstract fromRdfResourceValuesExpression(parameters: {
         variables: {
             context: Code;
             graph: Code;
@@ -213,7 +225,7 @@ export declare abstract class AbstractType {
      *   resourceSet: ResourceSet for any new Resources needed while conversion (of e.g., nested objects)
      *   value: value of this type, to be converted to (BlankNode | Literal | NamedNode | bigint | boolean | number | string) or an array of the same
      */
-    abstract toRdfExpression(parameters: {
+    abstract toRdfResourceValuesExpression(parameters: {
         variables: {
             graph: Code;
             propertyPath: Code;
@@ -231,9 +243,12 @@ export declare namespace AbstractType {
         readonly sourceTypeof: Typeof;
     }
     interface DiscriminantProperty {
+        readonly descendantValues: readonly DiscriminantProperty.Value[];
         readonly name: string;
-        readonly ownValues: readonly string[];
-        readonly descendantValues: readonly string[];
+        readonly ownValues: readonly DiscriminantProperty.Value[];
+    }
+    namespace DiscriminantProperty {
+        type Value = number | string;
     }
     class GraphqlType {
         /**