@shaclmate/compiler 4.0.98 → 4.0.100

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

@@ -10,22 +10,21 @@ import { ObjectType_IdentifierProperty } from "./_ObjectType/ObjectType_Identifi
 import type { ObjectType_Property } from "./_ObjectType/ObjectType_Property.js";
 import { ObjectType_RdfTypeProperty } from "./_ObjectType/ObjectType_RdfTypeProperty.js";
 import { ObjectType_ShaclProperty } from "./_ObjectType/ObjectType_ShaclProperty.js";
-import { ObjectType_schemaExpression } from "./_ObjectType/ObjectType_schemaExpression.js";
-import { ObjectType_schemaTypeExpression } from "./_ObjectType/ObjectType_schemaTypeExpression.js";
 import { ObjectType_toJsonObjectFunctionExpression, ObjectType_toJsonObjectFunctionType } from "./_ObjectType/ObjectType_toJsonObjectFunction.js";
 import { ObjectType_toLoggableFunctionExpression, ObjectType_toLoggableFunctionType } from "./_ObjectType/ObjectType_toLoggableFunction.js";
 import { ObjectType_toRdfResourceValuesFunctionExpression, ObjectType_toRdfResourceValuesFunctionType } from "./_ObjectType/ObjectType_toRdfResourceValuesFunction.js";
 import { ObjectType_toStringFunctionExpression, ObjectType_toStringFunctionType } from "./_ObjectType/ObjectType_toStringFunction.js";
 import { ObjectType_valueSparqlConstructTriplesFunctionExpression } from "./_ObjectType/ObjectType_valueSparqlConstructTriplesFunction.js";
 import { ObjectType_valueSparqlWherePatternsFunctionExpression } from "./_ObjectType/ObjectType_valueSparqlWherePatternsFunction.js";
-import { AbstractStructuredType } from "./AbstractStructuredType.js";
+import { AbstractUserDefinedType } from "./AbstractUserDefinedType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
 import type { Callable } from "./Callable.js";
 import type { IdentifierType } from "./IdentifierType.js";
 import type { IriType } from "./IriType.js";
+import { SchemaObject } from "./SchemaObject.js";
 import type { Type } from "./Type.js";
 import { type Code } from "./ts-poet-wrapper.js";
-export declare class ObjectType extends AbstractStructuredType {
+export declare class ObjectType extends AbstractUserDefinedType {
     private readonly rdfTypeProperty;
     protected equalsFunctionExpression: typeof ObjectType_equalsFunctionExpression;
     protected equalsFunctionType: typeof ObjectType_equalsFunctionType;
@@ -38,8 +37,6 @@ export declare class ObjectType extends AbstractStructuredType {
     protected fromRdfResourceValuesFunctionType: typeof ObjectType_fromRdfResourceValuesFunctionType;
     protected hashFunctionExpression: typeof ObjectType_hashFunctionExpression;
     protected hashFunctionType: typeof ObjectType_hashFunctionType;
-    protected schemaExpression: typeof ObjectType_schemaExpression;
-    protected schemaTypeExpression: typeof ObjectType_schemaTypeExpression;
     protected toJsonObjectFunctionExpression: typeof ObjectType_toJsonObjectFunctionExpression;
     protected toJsonObjectFunctionType: typeof ObjectType_toJsonObjectFunctionType;
     protected toLoggableFunctionExpression: typeof ObjectType_toLoggableFunctionExpression;
@@ -50,9 +47,9 @@ export declare class ObjectType extends AbstractStructuredType {
     protected toStringFunctionType: typeof ObjectType_toStringFunctionType;
     protected valueSparqlConstructTriplesFunctionExpression: typeof ObjectType_valueSparqlConstructTriplesFunctionExpression;
     protected valueSparqlWherePatternsFunctionExpression: typeof ObjectType_valueSparqlWherePatternsFunctionExpression;
-    readonly discriminatedType: Maybe<AbstractStructuredType.DiscriminatedType>;
+    readonly discriminatedType: Maybe<AbstractUserDefinedType.DiscriminatedType>;
     readonly extern: boolean;
-    readonly graphqlArgs: AbstractStructuredType["graphqlArgs"];
+    readonly graphqlArgs: AbstractUserDefinedType["graphqlArgs"];
     readonly identifierProperty: Maybe<ObjectType.IdentifierProperty>;
     readonly identifierType: BlankNodeType | IdentifierType | IriType;
     readonly jsTypes: readonly [{
@@ -62,7 +59,7 @@ export declare class ObjectType extends AbstractStructuredType {
     readonly kind = "Object";
     readonly recursive: boolean;
     readonly synthetic: boolean;
-    readonly validationFunction: AbstractStructuredType["validationFunction"];
+    readonly validationFunction: AbstractUserDefinedType["validationFunction"];
     constructor({ discriminantProperty, extern, identifierProperty, identifierType, lazyProperties, rdfTypeProperty, recursive, synthetic, ...superParameters }: {
         discriminantProperty: Maybe<ObjectType.DiscriminantProperty>;
         comment: Maybe<string>;
@@ -74,21 +71,22 @@ export declare class ObjectType extends AbstractStructuredType {
         rdfTypeProperty: Maybe<ObjectType.RdfTypeProperty>;
         recursive: boolean;
         synthetic: boolean;
-    } & ConstructorParameters<typeof AbstractStructuredType>[0]);
+    } & ConstructorParameters<typeof AbstractUserDefinedType>[0]);
     get _fromRdfResourceFunction(): Callable;
     get _toRdfResourceFunction(): Callable;
-    get jsonValueType(): AbstractStructuredType["jsonObjectType"];
-    get conversionFunction(): Maybe<AbstractStructuredType.ConversionFunction>;
+    get jsonValueType(): AbstractUserDefinedType["jsonObjectType"];
+    get conversionFunction(): Maybe<AbstractUserDefinedType.ConversionFunction>;
     get createFunction(): Callable;
     get createFunctionParameters(): ObjectType.CreateFunctionParameters;
     get createUnsafeFunction(): Callable;
     get declaration(): Maybe<Code>;
-    get jsonObjectType(): AbstractStructuredType["jsonObjectType"];
+    get jsonObjectType(): AbstractUserDefinedType["jsonObjectType"];
+    get schema(): SchemaObject<SchemaObject.UserDefinedType>;
     get focusSparqlConstructTriplesFunction(): Callable;
     get focusSparqlWherePatternsFunction(): Callable;
     get fromRdfResourceFunction(): Callable;
     get fromRdfTypeVariable(): Maybe<Code>;
-    get graphqlType(): AbstractStructuredType.GraphqlType;
+    get graphqlType(): AbstractUserDefinedType.GraphqlType;
     get identifierTypeAlias(): Code;
     get mutable(): boolean;
     get objectSetMethodNames(): ObjectType.ObjectSetMethodNames;
@@ -97,7 +95,7 @@ export declare class ObjectType extends AbstractStructuredType {
     get sparqlConstructQueryFunction(): Callable;
     get sparqlConstructQueryStringFunction(): Callable;
     get toRdfResourceFunction(): Callable;
-    get toRdfResourceValueTypes(): AbstractStructuredType["toRdfResourceValueTypes"];
+    get toRdfResourceValueTypes(): AbstractUserDefinedType["toRdfResourceValueTypes"];
     get toRdfjsResourceType(): Code;
     get toStringRecordFunction(): Callable;
     get typeGuardFunction(): Maybe<Callable>;

package/dist/generators/ts/ObjectType.js

@@ -28,11 +28,10 @@ import { ObjectType_graphqlTypeExpression } from "./_ObjectType/ObjectType_graph
 import { ObjectType_hashFunctionExpression, ObjectType_hashFunctionType, } from "./_ObjectType/ObjectType_hashFunction.js";
 import { ObjectType_IdentifierProperty } from "./_ObjectType/ObjectType_IdentifierProperty.js";
 import { ObjectType_identifierTypeDeclarations } from "./_ObjectType/ObjectType_identifierTypeDeclarations.js";
+import { ObjectType_jsonObjectType } from "./_ObjectType/ObjectType_jsonObjectType.js";
 import { ObjectType_objectSetMethodNames } from "./_ObjectType/ObjectType_objectSetMethodNames.js";
 import { ObjectType_RdfTypeProperty } from "./_ObjectType/ObjectType_RdfTypeProperty.js";
 import { ObjectType_ShaclProperty } from "./_ObjectType/ObjectType_ShaclProperty.js";
-import { ObjectType_schemaExpression } from "./_ObjectType/ObjectType_schemaExpression.js";
-import { ObjectType_schemaTypeExpression } from "./_ObjectType/ObjectType_schemaTypeExpression.js";
 import { ObjectType_sparqlConstructQueryFunction } from "./_ObjectType/ObjectType_sparqlConstructQueryFunction.js";
 import { ObjectType_sparqlConstructQueryStringFunction } from "./_ObjectType/ObjectType_sparqlConstructQueryStringFunction.js";
 import { ObjectType_toJsonObjectFunctionExpression, ObjectType_toJsonObjectFunctionType, } from "./_ObjectType/ObjectType_toJsonObjectFunction.js";
@@ -44,10 +43,11 @@ import { ObjectType_toStringRecordFunction } from "./_ObjectType/ObjectType_toSt
 import { ObjectType_typeGuardFunction } from "./_ObjectType/ObjectType_typeGuardFunction.js";
 import { ObjectType_valueSparqlConstructTriplesFunctionExpression } from "./_ObjectType/ObjectType_valueSparqlConstructTriplesFunction.js";
 import { ObjectType_valueSparqlWherePatternsFunctionExpression } from "./_ObjectType/ObjectType_valueSparqlWherePatternsFunction.js";
-import { AbstractStructuredType } from "./AbstractStructuredType.js";
+import { AbstractUserDefinedType } from "./AbstractUserDefinedType.js";
 import { DeclaredCallable } from "./DeclaredCallable.js";
+import { SchemaObject } from "./SchemaObject.js";
 import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
-export class ObjectType extends AbstractStructuredType {
+export class ObjectType extends AbstractUserDefinedType {
     rdfTypeProperty;
     equalsFunctionExpression = ObjectType_equalsFunctionExpression;
     equalsFunctionType = ObjectType_equalsFunctionType;
@@ -60,8 +60,6 @@ export class ObjectType extends AbstractStructuredType {
     fromRdfResourceValuesFunctionType = ObjectType_fromRdfResourceValuesFunctionType;
     hashFunctionExpression = ObjectType_hashFunctionExpression;
     hashFunctionType = ObjectType_hashFunctionType;
-    schemaExpression = ObjectType_schemaExpression;
-    schemaTypeExpression = ObjectType_schemaTypeExpression;
     toJsonObjectFunctionExpression = ObjectType_toJsonObjectFunctionExpression;
     toJsonObjectFunctionType = ObjectType_toJsonObjectFunctionType;
     toLoggableFunctionExpression = ObjectType_toLoggableFunctionExpression;
@@ -125,8 +123,30 @@ export class ObjectType extends AbstractStructuredType {
         return !this.extern ? super.declaration : Maybe.empty();
     }
     get jsonObjectType() {
-        return this.jsonTypeFactory.createJsonObjectType(this.properties.flatMap((property) => property.jsonObjectMember.toList()), {
-            name: this.name.map((name) => [name, "Json"]).extract(),
+        return ObjectType_jsonObjectType.call(this);
+    }
+    get schema() {
+        return new SchemaObject({
+            properties: {
+                ...super.schema.properties,
+                properties: () => code `properties: { ${joinCode(this.properties.flatMap((property) => property.schema
+                    .map((propertySchema) => [
+                    code `${property.name}: ${propertySchema.literalExpression}`,
+                ])
+                    .orDefault([])), { on: "," })} }`,
+            },
+            type: new SchemaObject.UserDefinedType({
+                members: {
+                    ...super.schema.type.members,
+                    properties: () => code `properties: { ${joinCode(this.properties.flatMap((property) => property.schema
+                        .map((propertySchema) => [
+                        code `${property.name}: ${propertySchema.type.literalExpression}`,
+                    ])
+                        .orDefault([])), { on: "," })} }`,
+                },
+                name: super.schema.type.name,
+            }),
+            variable: super.schema.variable,
         });
     }
     get focusSparqlConstructTriplesFunction() {
@@ -144,7 +164,7 @@ export class ObjectType extends AbstractStructuredType {
             .orDefaultLazy(() => this.rdfjsTermExpression(rdfTypeProperty.fromRdfType)));
     }
     get graphqlType() {
-        return new AbstractStructuredType.GraphqlType(this.name
+        return new AbstractUserDefinedType.GraphqlType(this.name
             .map((name) => code `${name}.GraphQL`)
             .orDefaultLazy(() => ObjectType_graphqlTypeExpression.call(this)), this.reusables);
     }
@@ -343,6 +363,9 @@ __decorate([
 __decorate([
     Memoize()
 ], ObjectType.prototype, "jsonObjectType", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "schema", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "focusSparqlConstructTriplesFunction", null);

package/dist/generators/ts/OptionType.d.ts

@@ -1,6 +1,7 @@
 import { Maybe } from "purify-ts";
 import { AbstractContainerType } from "./AbstractContainerType.js";
 import type { Callable } from "./Callable.js";
+import { SchemaObject } from "./SchemaObject.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class OptionType<ItemTypeT extends OptionType.ItemType> extends AbstractContainerType<ItemTypeT> {
     readonly graphqlArgs: AbstractContainerType<ItemTypeT>["graphqlArgs"];
@@ -21,7 +22,7 @@ export declare class OptionType<ItemTypeT extends OptionType.ItemType> extends A
     get graphqlType(): AbstractContainerType.GraphqlType;
     get hashFunction(): Callable;
     get mutable(): boolean;
-    get schemaType(): Code;
+    get schema(): SchemaObject<SchemaObject.BuiltinType>;
     get toJsonValueFunction(): AbstractContainerType<ItemTypeT>["toJsonValueFunction"];
     get toJsonObjectFunction(): AbstractContainerType<ItemTypeT>["toJsonObjectFunction"];
     get toRdfResourceValueTypes(): AbstractContainerType<ItemTypeT>["toRdfResourceValueTypes"];

package/dist/generators/ts/OptionType.js

@@ -8,9 +8,10 @@ import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractContainerType } from "./AbstractContainerType.js";
+import { BuiltinCallable } from "./BuiltinCallable.js";
 import { codeEquals } from "./codeEquals.js";
 import { InlineCallable } from "./InlineCallable.js";
-import { ReferenceCallable } from "./ReferenceCallable.js";
+import { SchemaObject } from "./SchemaObject.js";
 import { code } from "./ts-poet-wrapper.js";
 export class OptionType extends AbstractContainerType {
     graphqlArgs = Maybe.empty();
@@ -47,13 +48,13 @@ export class OptionType extends AbstractContainerType {
         return code `${this.reusables.snippets.MaybeFilter}<${this.itemType.filterType}>`;
     }
     get fromJsonValueFunction() {
-        return new ReferenceCallable(code `${this.reusables.snippets.maybeFromJsonValue}(${this.itemType.fromJsonValueFunction.annotatedUsage})`);
+        return new BuiltinCallable(code `${this.reusables.snippets.maybeFromJsonValue}(${this.itemType.fromJsonValueFunction.annotatedUsage})`);
     }
     get fromJsonObjectFunction() {
-        return new ReferenceCallable(code `${this.reusables.snippets.maybeFromJsonObject}(${this.itemType.fromJsonObjectFunction.annotatedUsage})`);
+        return new BuiltinCallable(code `${this.reusables.snippets.maybeFromJsonObject}(${this.itemType.fromJsonObjectFunction.annotatedUsage})`);
     }
     get fromRdfResourceValuesFunction() {
-        return new InlineCallable(code `${this.reusables.snippets.maybeFromRdfResourceValues}<${this.itemType.expression}, ${this.itemType.schemaType}>(${this.itemType.fromRdfResourceValuesFunction.unannotatedUsage})`);
+        return new InlineCallable(code `${this.reusables.snippets.maybeFromRdfResourceValues}<${this.itemType.expression}, ${this.itemType.schema.type.expression}>(${this.itemType.fromRdfResourceValuesFunction.unannotatedUsage})`);
     }
     get graphqlType() {
         invariant(!this.itemType.graphqlType.nullable);
@@ -67,14 +68,18 @@ export class OptionType extends AbstractContainerType {
     get mutable() {
         return this.itemType.mutable;
     }
-    get schemaType() {
-        return code `${this.reusables.snippets.MaybeSchema}<${this.itemType.schemaType}>`;
+    get schema() {
+        return new SchemaObject({
+            properties: super.schema.properties,
+            type: new SchemaObject.BuiltinType(code `${this.reusables.snippets.MaybeSchema}<${this.itemType.schema.type.expression}>`),
+            variable: super.schema.variable,
+        });
     }
     get toJsonValueFunction() {
-        return new ReferenceCallable(code `${this.reusables.snippets.maybeToJsonValue}(${this.itemType.toJsonValueFunction.annotatedUsage})`);
+        return new BuiltinCallable(code `${this.reusables.snippets.maybeToJsonValue}(${this.itemType.toJsonValueFunction.annotatedUsage})`);
     }
     get toJsonObjectFunction() {
-        return new ReferenceCallable(code `${this.reusables.snippets.maybeToJsonObject}(${this.itemType.toJsonObjectFunction.annotatedUsage})`);
+        return new BuiltinCallable(code `${this.reusables.snippets.maybeToJsonObject}(${this.itemType.toJsonObjectFunction.annotatedUsage})`);
     }
     get toRdfResourceValueTypes() {
         return this.itemType.toRdfResourceValueTypes;
@@ -85,10 +90,10 @@ export class OptionType extends AbstractContainerType {
             .orDefault(this.itemValidationFunctionDefault.annotatedUsage)})`));
     }
     get valueSparqlConstructTriplesFunction() {
-        return new InlineCallable(code `${this.reusables.snippets.maybeSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlConstructTriplesFunction.unannotatedUsage})`);
+        return new InlineCallable(code `${this.reusables.snippets.maybeSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schema.type.expression}>(${this.itemType.valueSparqlConstructTriplesFunction.unannotatedUsage})`);
     }
     get valueSparqlWherePatternsFunction() {
-        return new InlineCallable(code `${this.reusables.snippets.maybeSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction.unannotatedUsage})`);
+        return new InlineCallable(code `${this.reusables.snippets.maybeSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schema.type.expression}>(${this.itemType.valueSparqlWherePatternsFunction.unannotatedUsage})`);
     }
     get inlineExpression() {
         return code `${this.reusables.imports.Maybe}<${this.itemType.expression}>`;
@@ -142,7 +147,7 @@ __decorate([
 ], OptionType.prototype, "hashFunction", null);
 __decorate([
     Memoize()
-], OptionType.prototype, "schemaType", null);
+], OptionType.prototype, "schema", null);
 __decorate([
     Memoize()
 ], OptionType.prototype, "toJsonValueFunction", null);

package/dist/generators/ts/SchemaObject.d.ts

@@ -0,0 +1,98 @@
+import type { Maybe } from "purify-ts";
+import { CodeThunk } from "./CodeThunk.js";
+import type { Snippet } from "./Snippet.js";
+import { type Code } from "./ts-poet-wrapper.js";
+/**
+ * Runtime schema/metadata objects for types and properties.
+ */
+export declare class SchemaObject<TypeT extends SchemaObject.Type> {
+    /**
+     * Object literal properties, usually property assignments like name: value
+     * without a terminating comma.
+     *
+     * Note the name is repeated between the key and the value:
+     *   { name: code`name: value` }
+     * Only the value is incorporated into generated code. The keys are used to sort properties.
+     *
+     * This enables overwriting in the *Type tree while also supporting non-property assignments such as
+     *   { name: code`get name() { return value; }` }
+     * or
+     *   { shorthand: code `shorthand` }
+     */
+    readonly properties: Readonly<Record<string, CodeThunk>>;
+    /**
+     * Type of the schema object.
+     */
+    readonly type: TypeT;
+    /**
+     * Variable pointing to the schema object.
+     */
+    readonly variable: Maybe<Code>;
+    constructor({ properties, type, variable, }: {
+        properties: Readonly<Record<string, CodeThunk>>;
+        type: TypeT;
+        variable: Maybe<Code>;
+    });
+    /**
+     * Expression for this schema object, either the variable or a literal expression.
+     */
+    get expression(): Code;
+    /**
+     * Literal expression of the schema object e.g., { name1: value1, name2: value2 }
+     */
+    get literalExpression(): Code;
+    toString(): string;
+}
+export declare namespace SchemaObject {
+    /**
+     * Placeholder for abstract base classes.
+     */
+    class AbstractType {
+        private readonly ownerKind;
+        constructor(ownerKind: string);
+        get expression(): Code;
+        toString(): string;
+    }
+    /**
+     * A built-in schema object type from a snippet or import.
+     */
+    class BuiltinType {
+        readonly expression: Code;
+        constructor(expression: Code | Snippet);
+        toString(): string;
+    }
+    /**
+     * A user-defined schema object type, typically corresponding to user-defined types.
+     */
+    class UserDefinedType {
+        /**
+         * Members of the schema object type, usually property signatures like name: string.
+         *
+         * Note the name is repeated between the key and the value:
+         *   { name: code`name: string` }
+         * This enables overwriting in the *Type tree. Unlike property assignments (above),
+         * we don't really need to support other member types (index signatures, methods, et al.).
+         * Rather, the name is repeated here for consistency with property assignments.
+         */
+        readonly members: Readonly<Record<string, CodeThunk>>;
+        /**
+         * Name of the type, can be used in type annotations.
+         */
+        readonly name: Maybe<Code>;
+        constructor({ members, name, }: {
+            members: Readonly<Record<string, CodeThunk>>;
+            name: Maybe<Code>;
+        });
+        /**
+         * Expression of the schema object type, either the name or a literal expression.
+         */
+        get expression(): Code;
+        /**
+         * Literal expression of the schema object type e.g., { name1: string, name2: string }.
+         */
+        get literalExpression(): Code;
+        toString(): string;
+    }
+    type Type = AbstractType | BuiltinType | UserDefinedType;
+}
+//# sourceMappingURL=SchemaObject.d.ts.map

package/dist/generators/ts/SchemaObject.js

@@ -0,0 +1,143 @@
+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 { Memoize } from "typescript-memoize";
+import { CodeThunk } from "./CodeThunk.js";
+import { code, joinCode } from "./ts-poet-wrapper.js";
+/**
+ * Runtime schema/metadata objects for types and properties.
+ */
+export class SchemaObject {
+    /**
+     * Object literal properties, usually property assignments like name: value
+     * without a terminating comma.
+     *
+     * Note the name is repeated between the key and the value:
+     *   { name: code`name: value` }
+     * Only the value is incorporated into generated code. The keys are used to sort properties.
+     *
+     * This enables overwriting in the *Type tree while also supporting non-property assignments such as
+     *   { name: code`get name() { return value; }` }
+     * or
+     *   { shorthand: code `shorthand` }
+     */
+    properties;
+    /**
+     * Type of the schema object.
+     */
+    type;
+    /**
+     * Variable pointing to the schema object.
+     */
+    variable;
+    constructor({ properties, type, variable, }) {
+        this.properties = properties;
+        this.type = type;
+        this.variable = variable;
+    }
+    /**
+     * Expression for this schema object, either the variable or a literal expression.
+     */
+    get expression() {
+        return this.variable.orDefaultLazy(() => this.literalExpression);
+    }
+    /**
+     * Literal expression of the schema object e.g., { name1: value1, name2: value2 }
+     */
+    get literalExpression() {
+        return code `{ ${joinCode(Object.keys(this.properties)
+            .sort()
+            .map((key) => CodeThunk.evaluate(this.properties[key])), { on: ", " })} } as const`;
+    }
+    toString() {
+        throw new Error("should never be called");
+    }
+}
+__decorate([
+    Memoize()
+], SchemaObject.prototype, "expression", null);
+__decorate([
+    Memoize()
+], SchemaObject.prototype, "literalExpression", null);
+(function (SchemaObject) {
+    /**
+     * Placeholder for abstract base classes.
+     */
+    class AbstractType {
+        ownerKind;
+        constructor(ownerKind) {
+            this.ownerKind = ownerKind;
+        }
+        get expression() {
+            throw new Error(`should never be called (instantiated by ${this.ownerKind})`);
+        }
+        toString() {
+            throw new Error("should never be called");
+        }
+    }
+    SchemaObject.AbstractType = AbstractType;
+    /**
+     * A built-in schema object type from a snippet or import.
+     */
+    class BuiltinType {
+        expression;
+        constructor(expression) {
+            this.expression = code `${expression}`;
+        }
+        toString() {
+            throw new Error("should never be called");
+        }
+    }
+    SchemaObject.BuiltinType = BuiltinType;
+    /**
+     * A user-defined schema object type, typically corresponding to user-defined types.
+     */
+    class UserDefinedType {
+        /**
+         * Members of the schema object type, usually property signatures like name: string.
+         *
+         * Note the name is repeated between the key and the value:
+         *   { name: code`name: string` }
+         * This enables overwriting in the *Type tree. Unlike property assignments (above),
+         * we don't really need to support other member types (index signatures, methods, et al.).
+         * Rather, the name is repeated here for consistency with property assignments.
+         */
+        members;
+        /**
+         * Name of the type, can be used in type annotations.
+         */
+        name;
+        constructor({ members, name, }) {
+            this.members = members;
+            this.name = name;
+        }
+        /**
+         * Expression of the schema object type, either the name or a literal expression.
+         */
+        get expression() {
+            return this.name.orDefaultLazy(() => this.literalExpression);
+        }
+        /**
+         * Literal expression of the schema object type e.g., { name1: string, name2: string }.
+         */
+        get literalExpression() {
+            return code `{ ${joinCode(Object.keys(this.members)
+                .sort()
+                .map((key) => code `${CodeThunk.evaluate(this.members[key])};`))} }`;
+        }
+        toString() {
+            throw new Error("should never be called");
+        }
+    }
+    __decorate([
+        Memoize()
+    ], UserDefinedType.prototype, "expression", null);
+    __decorate([
+        Memoize()
+    ], UserDefinedType.prototype, "literalExpression", null);
+    SchemaObject.UserDefinedType = UserDefinedType;
+})(SchemaObject || (SchemaObject = {}));
+//# sourceMappingURL=SchemaObject.js.map

package/dist/generators/ts/SetType.d.ts

@@ -1,6 +1,7 @@
 import { Maybe } from "purify-ts";
 import { AbstractCollectionType } from "./AbstractCollectionType.js";
 import type { Callable } from "./Callable.js";
+import { SchemaObject } from "./SchemaObject.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class SetType<ItemTypeT extends SetType.ItemType> extends AbstractCollectionType<ItemTypeT> {
     readonly graphqlArgs: AbstractCollectionType<ItemTypeT>["graphqlArgs"];
@@ -24,7 +25,7 @@ export declare class SetType<ItemTypeT extends SetType.ItemType> extends Abstrac
     get toRdfResourceValueTypes(): AbstractCollectionType<ItemTypeT>["toRdfResourceValueTypes"];
     get valueSparqlConstructTriplesFunction(): Callable;
     get valueSparqlWherePatternsFunction(): Callable;
-    protected get schemaInitializers(): readonly Code[];
+    get schema(): SchemaObject<SchemaObject.BuiltinType>;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["toRdfResourceValuesExpression"]>[0]): Code;
     toStringExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["toStringExpression"]>[0]): Code;
 }

package/dist/generators/ts/SetType.js

@@ -8,8 +8,9 @@ import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractCollectionType } from "./AbstractCollectionType.js";
+import { BuiltinCallable } from "./BuiltinCallable.js";
 import { InlineCallable } from "./InlineCallable.js";
-import { ReferenceCallable } from "./ReferenceCallable.js";
+import { SchemaObject } from "./SchemaObject.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 export class SetType extends AbstractCollectionType {
     graphqlArgs = Maybe.empty();
@@ -70,16 +71,16 @@ export class SetType extends AbstractCollectionType {
         throw new Error("should never be called");
     }
     get fromJsonValueFunction() {
-        return new ReferenceCallable(code `${this.reusables.snippets.arrayFromJsonArray}(${this.itemType.fromJsonValueFunction.annotatedUsage})`);
+        return new BuiltinCallable(code `${this.reusables.snippets.arrayFromJsonArray}(${this.itemType.fromJsonValueFunction.annotatedUsage})`);
     }
     get fromJsonObjectFunction() {
         throw new Error("should never be called");
     }
     get fromRdfResourceValuesFunction() {
-        return new InlineCallable(code `${this._mutable ? this.reusables.snippets.mutableSetFromRdfResourceValues : this.reusables.snippets.setFromRdfResourceValues}<${this.itemType.expression}, ${this.itemType.schemaType}>(${this.itemType.fromRdfResourceValuesFunction.unannotatedUsage})`);
+        return new InlineCallable(code `${this._mutable ? this.reusables.snippets.mutableSetFromRdfResourceValues : this.reusables.snippets.setFromRdfResourceValues}<${this.itemType.expression}, ${this.itemType.schema.type.expression}>(${this.itemType.fromRdfResourceValuesFunction.unannotatedUsage})`);
     }
     get toJsonValueFunction() {
-        return new ReferenceCallable(code `${this.reusables.snippets.arrayToJsonArray}(${this.itemType.toJsonValueFunction.annotatedUsage})`);
+        return new BuiltinCallable(code `${this.reusables.snippets.arrayToJsonArray}(${this.itemType.toJsonValueFunction.annotatedUsage})`);
     }
     get toJsonObjectFunction() {
         throw new Error("should never be called");
@@ -88,17 +89,25 @@ export class SetType extends AbstractCollectionType {
         return this.itemType.toRdfResourceValueTypes;
     }
     get valueSparqlConstructTriplesFunction() {
-        return new InlineCallable(code `${this.reusables.snippets.setSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlConstructTriplesFunction.unannotatedUsage})`);
+        return new InlineCallable(code `${this.reusables.snippets.setSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schema.type.expression}>(${this.itemType.valueSparqlConstructTriplesFunction.unannotatedUsage})`);
     }
     get valueSparqlWherePatternsFunction() {
-        return new InlineCallable(code `${this.reusables.snippets.setSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction.unannotatedUsage})`);
+        return new InlineCallable(code `${this.reusables.snippets.setSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schema.type.expression}>(${this.itemType.valueSparqlWherePatternsFunction.unannotatedUsage})`);
     }
-    get schemaInitializers() {
-        let schemaInitializers = super.schemaInitializers;
+    get schema() {
         if (this.minCount > 0n) {
-            schemaInitializers = schemaInitializers.concat(code `minCount: ${Number(this.minCount)}`);
+            return new SchemaObject({
+                properties: {
+                    ...super.schema.properties,
+                    minCount: code `minCount: ${Number(this.minCount)}`,
+                },
+                type: super.schema.type,
+                variable: super.schema.variable,
+            });
+        }
+        else {
+            return super.schema;
         }
-        return schemaInitializers;
     }
     toRdfResourceValuesExpression({ variables, }) {
         return code `${variables.value}.flatMap((item) => ${this.itemType.toRdfResourceValuesExpression({
@@ -130,6 +139,9 @@ __decorate([
 __decorate([
     Memoize()
 ], SetType.prototype, "valueSparqlWherePatternsFunction", null);
+__decorate([
+    Memoize()
+], SetType.prototype, "schema", null);
 (function (SetType) {
     SetType.isItemType = AbstractCollectionType.isItemType;
 })(SetType || (SetType = {}));

package/dist/generators/ts/Snippets.d.ts

@@ -45,6 +45,7 @@ export declare class Snippets {
     get LangStringSchema(): Snippet;
     get Lazy(): Snippet;
     get LazyOption(): Snippet;
+    get LazySchema(): Snippet;
     get LazySet(): Snippet;
     get LiteralFilter(): Snippet;
     get LiteralJsonObject(): Snippet;

package/dist/generators/ts/Snippets.js

@@ -39,6 +39,7 @@ import { snippets_LangStringJsonObject } from "./_snippets/snippets_LangStringJs
 import { snippets_LangStringSchema } from "./_snippets/snippets_LangStringSchema.js";
 import { snippets_Lazy } from "./_snippets/snippets_Lazy.js";
 import { snippets_LazyOption } from "./_snippets/snippets_LazyOption.js";
+import { snippets_LazySchema } from "./_snippets/snippets_LazySchema.js";
 import { snippets_LazySet } from "./_snippets/snippets_LazySet.js";
 import { snippets_LiteralFilter } from "./_snippets/snippets_LiteralFilter.js";
 import { snippets_LiteralJsonObject } from "./_snippets/snippets_LiteralJsonObject.js";
@@ -359,6 +360,9 @@ export class Snippets {
     get LazyOption() {
         return this.snippet(snippets_LazyOption);
     }
+    get LazySchema() {
+        return this.snippet(snippets_LazySchema);
+    }
     get LazySet() {
         return this.snippet(snippets_LazySet);
     }
@@ -1166,6 +1170,9 @@ __decorate([
 __decorate([
     Memoize()
 ], Snippets.prototype, "LazyOption", null);
+__decorate([
+    Memoize()
+], Snippets.prototype, "LazySchema", null);
 __decorate([
     Memoize()
 ], Snippets.prototype, "LazySet", null);