@shaclmate/compiler 4.0.97 → 4.0.99

package/dist/generators/ts/AbstractCollectionType.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";
 /**
  * Abstract base class for ListType and SetType.
@@ -15,9 +16,9 @@ export declare abstract class AbstractCollectionType<ItemTypeT extends AbstractC
     get filterFunction(): Callable;
     get filterType(): Code;
     get graphqlType(): AbstractContainerType.GraphqlType;
+    get schema(): SchemaObject<SchemaObject.BuiltinType>;
     get hashFunction(): Callable;
     get mutable(): boolean;
-    get schemaType(): Code;
     get validationFunction(): Maybe<Callable>;
     protected get inlineExpression(): Code;
     graphqlResolveExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["graphqlResolveExpression"]>[0]): Code;

package/dist/generators/ts/AbstractCollectionType.js

@@ -8,6 +8,7 @@ import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractContainerType } from "./AbstractContainerType.js";
 import { InlineCallable } from "./InlineCallable.js";
+import { SchemaObject } from "./SchemaObject.js";
 import { code } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class for ListType and SetType.
@@ -33,15 +34,19 @@ export class AbstractCollectionType extends AbstractContainerType {
     get graphqlType() {
         return new AbstractContainerType.GraphqlType(code `new ${this.reusables.imports.GraphQLList}(${this.itemType.graphqlType.expression})`, this.reusables);
     }
+    get schema() {
+        return new SchemaObject({
+            properties: super.schema.properties,
+            type: new SchemaObject.BuiltinType(code `${this.reusables.snippets.CollectionSchema}<${this.itemType.schema.type.expression}>`),
+            variable: super.schema.variable,
+        });
+    }
     get hashFunction() {
         return new InlineCallable(code `${this.reusables.snippets.hashArray}(${this.itemType.hashFunction.annotatedUsage})`);
     }
     get mutable() {
         return this._mutable || this.itemType.mutable;
     }
-    get schemaType() {
-        return code `${this.reusables.snippets.CollectionSchema}<${this.itemType.schemaType}>`;
-    }
     get validationFunction() {
         return Maybe.of(new InlineCallable(code `${this._mutable ? this.reusables.snippets.validateMutableArray : this.reusables.snippets.validateArray}(${this.itemType.validationFunction
             .map((_) => _.unannotatedUsage)
@@ -71,10 +76,10 @@ __decorate([
 ], AbstractCollectionType.prototype, "graphqlType", null);
 __decorate([
     Memoize()
-], AbstractCollectionType.prototype, "hashFunction", null);
+], AbstractCollectionType.prototype, "schema", null);
 __decorate([
     Memoize()
-], AbstractCollectionType.prototype, "schemaType", null);
+], AbstractCollectionType.prototype, "hashFunction", null);
 __decorate([
     Memoize()
 ], AbstractCollectionType.prototype, "validationFunction", null);

package/dist/generators/ts/AbstractCompoundType.d.ts

@@ -1,18 +1,21 @@
-import { AbstractStructuredType } from "./AbstractStructuredType.js";
+import { AbstractUserDefinedType } from "./AbstractUserDefinedType.js";
 import type { Type } from "./Type.js";
+/**
+ * A compound of types, such as an intersection or union.
+ */
 export declare abstract class AbstractCompoundType<MemberT extends {
     type: MemberTypeT;
-}, MemberTypeT extends Type> extends AbstractStructuredType {
+}, MemberTypeT extends Type> extends AbstractUserDefinedType {
     abstract readonly members: readonly MemberT[];
     get mutable(): boolean;
     get referencesNamedType(): boolean;
-    get toRdfResourceValueTypes(): AbstractStructuredType["toRdfResourceValueTypes"];
+    get toRdfResourceValueTypes(): AbstractUserDefinedType["toRdfResourceValueTypes"];
 }
 export declare namespace AbstractCompoundType {
-    type ConversionFunction = AbstractStructuredType.ConversionFunction;
-    type DiscriminatedType = AbstractStructuredType.DiscriminatedType;
-    type GraphqlType = AbstractStructuredType.GraphqlType;
-    type JsonType = AbstractStructuredType.JsonType;
-    type JsType = AbstractStructuredType.JsType;
+    type ConversionFunction = AbstractUserDefinedType.ConversionFunction;
+    type DiscriminatedType = AbstractUserDefinedType.DiscriminatedType;
+    type GraphqlType = AbstractUserDefinedType.GraphqlType;
+    type JsonType = AbstractUserDefinedType.JsonType;
+    type JsType = AbstractUserDefinedType.JsType;
 }
 //# sourceMappingURL=AbstractCompoundType.d.ts.map

package/dist/generators/ts/AbstractCompoundType.js

@@ -5,8 +5,11 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { Memoize } from "typescript-memoize";
-import { AbstractStructuredType } from "./AbstractStructuredType.js";
-export class AbstractCompoundType extends AbstractStructuredType {
+import { AbstractUserDefinedType } from "./AbstractUserDefinedType.js";
+/**
+ * A compound of types, such as an intersection or union.
+ */
+export class AbstractCompoundType extends AbstractUserDefinedType {
     get mutable() {
         return this.members.some((member) => member.type.mutable);
     }

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

@@ -1,5 +1,5 @@
 import { Maybe } from "purify-ts";
-import { AbstractType } from "./AbstractType.js";
+import { AbstractBuiltinType } from "./AbstractBuiltinType.js";
 import type { BigDecimalType } from "./BigDecimalType.js";
 import type { BigIntType } from "./BigIntType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
@@ -18,15 +18,15 @@ import type { LiteralType } from "./LiteralType.js";
 import type { ObjectDiscriminatedUnionType } from "./ObjectDiscriminatedUnionType.js";
 import type { ObjectIntersectionType } from "./ObjectIntersectionType.js";
 import type { ObjectType } from "./ObjectType.js";
+import { SchemaObject } from "./SchemaObject.js";
 import type { StringType } from "./StringType.js";
 import type { TermType } from "./TermType.js";
 import type { Type } from "./Type.js";
-import { type Code } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class for types that contain other types e.g., ListType, OptionType, SetType.
  */
-export declare abstract class AbstractContainerType<ItemTypeT extends AbstractContainerType.ItemType> extends AbstractType {
-    readonly discriminatedType: Maybe<AbstractType.DiscriminatedType>;
+export declare abstract class AbstractContainerType<ItemTypeT extends AbstractContainerType.ItemType> extends AbstractBuiltinType {
+    readonly discriminatedType: Maybe<AbstractBuiltinType.DiscriminatedType>;
     abstract readonly kind: "DefaultValue" | "List" | "Option" | "Set";
     /**
      * Container item type.
@@ -36,20 +36,20 @@ export declare abstract class AbstractContainerType<ItemTypeT extends AbstractCo
     itemType: ItemTypeT;
     constructor({ itemType, ...superParameters }: {
         itemType: ItemTypeT;
-    } & ConstructorParameters<typeof AbstractType>[0]);
+    } & ConstructorParameters<typeof AbstractBuiltinType>[0]);
     get recursive(): boolean;
     get referencesNamedType(): boolean;
-    protected get itemConversionFunctionDefault(): AbstractType.ConversionFunction;
+    get schema(): SchemaObject<SchemaObject.AbstractType | SchemaObject.BuiltinType>;
+    protected get itemConversionFunctionDefault(): AbstractBuiltinType.ConversionFunction;
     protected get itemValidationFunctionDefault(): Callable;
-    protected get schemaInitializers(): readonly Code[];
 }
 export declare namespace AbstractContainerType {
-    type ConversionFunction = AbstractType.ConversionFunction;
-    type DiscriminatedType = AbstractType.DiscriminatedType;
+    type ConversionFunction = AbstractBuiltinType.ConversionFunction;
+    type DiscriminatedType = AbstractBuiltinType.DiscriminatedType;
     const GraphqlType: typeof import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
-    type GraphqlType = AbstractType.GraphqlType;
+    type GraphqlType = AbstractBuiltinType.GraphqlType;
     type ItemType = BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | DiscriminatedUnionType | FloatType | IdentifierType | IntType | IriType | LangStringType | ListType<ListType.ItemType> | LiteralType | ObjectDiscriminatedUnionType | ObjectIntersectionType | ObjectType | StringType | TermType;
     function isItemType(type: Type): type is ItemType;
-    type JsonType = AbstractType.JsonType;
+    type JsonType = AbstractBuiltinType.JsonType;
 }
 //# sourceMappingURL=AbstractContainerType.d.ts.map

package/dist/generators/ts/AbstractContainerType.js

@@ -6,13 +6,14 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
-import { AbstractType } from "./AbstractType.js";
-import { ReferenceCallable } from "./ReferenceCallable.js";
+import { AbstractBuiltinType } from "./AbstractBuiltinType.js";
+import { BuiltinCallable } from "./BuiltinCallable.js";
+import { SchemaObject } from "./SchemaObject.js";
 import { code } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class for types that contain other types e.g., ListType, OptionType, SetType.
  */
-export class AbstractContainerType extends AbstractType {
+export class AbstractContainerType extends AbstractBuiltinType {
     discriminatedType = Maybe.empty();
     /**
      * Container item type.
@@ -30,6 +31,18 @@ export class AbstractContainerType extends AbstractType {
     get referencesNamedType() {
         return this.name.isJust() || this.itemType.referencesNamedType;
     }
+    get schema() {
+        return new SchemaObject({
+            properties: {
+                ...super.schema.properties,
+                itemType: this.recursive || this.referencesNamedType
+                    ? code `get itemType() { return ${this.itemType.schema.expression}; }`
+                    : code `itemType: ${this.itemType.schema.expression}`,
+            },
+            type: new SchemaObject.AbstractType("AbstractContainerType"),
+            variable: super.schema.variable,
+        });
+    }
     get itemConversionFunctionDefault() {
         return {
             code: code `${this.reusables.snippets.identityConversionFunction}`,
@@ -42,19 +55,12 @@ export class AbstractContainerType extends AbstractType {
         };
     }
     get itemValidationFunctionDefault() {
-        return new ReferenceCallable(this.reusables.snippets.identityValidationFunction);
-    }
-    get schemaInitializers() {
-        const initializers = super.schemaInitializers.concat();
-        if (this.recursive || this.referencesNamedType) {
-            initializers.push(code `get itemType() { return ${this.itemType.schema}; }`);
-        }
-        else {
-            initializers.push(code `itemType: ${this.itemType.schema}`);
-        }
-        return initializers;
+        return new BuiltinCallable(this.reusables.snippets.identityValidationFunction);
     }
 }
+__decorate([
+    Memoize()
+], AbstractContainerType.prototype, "schema", null);
 __decorate([
     Memoize()
 ], AbstractContainerType.prototype, "itemConversionFunctionDefault", null);
@@ -62,7 +68,7 @@ __decorate([
     Memoize()
 ], AbstractContainerType.prototype, "itemValidationFunctionDefault", null);
 (function (AbstractContainerType) {
-    AbstractContainerType.GraphqlType = AbstractType.GraphqlType;
+    AbstractContainerType.GraphqlType = AbstractBuiltinType.GraphqlType;
     function isItemType(type) {
         switch (type.kind) {
             case "BigDecimal":

package/dist/generators/ts/AbstractDateType.d.ts

@@ -1,6 +1,7 @@
 import { Maybe } from "purify-ts";
 import { AbstractTypedLiteralType } from "./AbstractTypedLiteralType.js";
-import { ReferenceCallable } from "./ReferenceCallable.js";
+import { BuiltinCallable } from "./BuiltinCallable.js";
+import { SchemaObject } from "./SchemaObject.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare abstract class AbstractDateType extends AbstractTypedLiteralType<Date> {
     protected readonly inlineExpression: Code;
@@ -9,17 +10,17 @@ export declare abstract class AbstractDateType extends AbstractTypedLiteralType<
      * Date has no conversion function to avoid source type overlap with other types (e.g., string).
      */
     readonly conversionFunction: Maybe<AbstractTypedLiteralType.ConversionFunction>;
-    readonly equalsFunction: ReferenceCallable;
-    readonly filterFunction: ReferenceCallable;
+    readonly equalsFunction: BuiltinCallable;
+    readonly filterFunction: BuiltinCallable;
     readonly filterType: Code;
-    readonly fromJsonValueFunction: ReferenceCallable;
+    readonly fromJsonValueFunction: BuiltinCallable;
     readonly jsTypes: readonly [{
         readonly instanceof: "Date";
         readonly typeof: "object";
     }];
-    readonly schemaType: Code;
-    readonly valueSparqlWherePatternsFunction: ReferenceCallable;
+    readonly valueSparqlWherePatternsFunction: BuiltinCallable;
     get jsonValueType(): AbstractTypedLiteralType.JsonType;
+    get schema(): SchemaObject<SchemaObject.BuiltinType>;
     toLoggableExpression({ variables, }: Parameters<AbstractTypedLiteralType<Date>["toLoggableExpression"]>[0]): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractTypedLiteralType<Date>["toRdfResourceValuesExpression"]>[0]): Code;
 }

package/dist/generators/ts/AbstractDateType.js

@@ -7,7 +7,8 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractTypedLiteralType } from "./AbstractTypedLiteralType.js";
-import { ReferenceCallable } from "./ReferenceCallable.js";
+import { BuiltinCallable } from "./BuiltinCallable.js";
+import { SchemaObject } from "./SchemaObject.js";
 import { code } from "./ts-poet-wrapper.js";
 export class AbstractDateType extends AbstractTypedLiteralType {
     inlineExpression = code `Date`;
@@ -15,23 +16,29 @@ export class AbstractDateType extends AbstractTypedLiteralType {
      * Date has no conversion function to avoid source type overlap with other types (e.g., string).
      */
     conversionFunction = Maybe.empty();
-    equalsFunction = new ReferenceCallable(this.reusables.snippets.dateEquals);
-    filterFunction = new ReferenceCallable(this.reusables.snippets.filterDate);
+    equalsFunction = new BuiltinCallable(this.reusables.snippets.dateEquals);
+    filterFunction = new BuiltinCallable(this.reusables.snippets.filterDate);
     filterType = code `${this.reusables.snippets.DateFilter}`;
-    fromJsonValueFunction = new ReferenceCallable(this.reusables.snippets.dateFromJsonString);
+    fromJsonValueFunction = new BuiltinCallable(this.reusables.snippets.dateFromJsonString);
     jsTypes = [
         {
             instanceof: "Date",
             typeof: "object",
         },
     ];
-    schemaType = code `${this.reusables.snippets.DateSchema}`;
-    valueSparqlWherePatternsFunction = new ReferenceCallable(this.reusables.snippets.dateSparqlWherePatterns);
+    valueSparqlWherePatternsFunction = new BuiltinCallable(this.reusables.snippets.dateSparqlWherePatterns);
     get jsonValueType() {
         return this.jsonTypeFactory.createJsonStringType({
             format: this.jsonStringFormat,
         });
     }
+    get schema() {
+        return new SchemaObject({
+            properties: super.schema.properties,
+            type: new SchemaObject.BuiltinType(this.reusables.snippets.DateSchema),
+            variable: super.schema.variable,
+        });
+    }
     toLoggableExpression({ variables, }) {
         return code `${variables.value}.toISOString()`;
     }
@@ -42,4 +49,7 @@ export class AbstractDateType extends AbstractTypedLiteralType {
 __decorate([
     Memoize()
 ], AbstractDateType.prototype, "jsonValueType", null);
+__decorate([
+    Memoize()
+], AbstractDateType.prototype, "schema", null);
 //# sourceMappingURL=AbstractDateType.js.map

package/dist/generators/ts/AbstractDiscriminatedUnionType.d.ts

@@ -6,7 +6,6 @@ import { AbstractDiscriminatedUnionType_filterTypeExpression } from "./_Abstract
 import { AbstractDiscriminatedUnionType_fromJsonObjectFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_fromJsonObjectFunction.js";
 import { AbstractDiscriminatedUnionType_fromRdfResourceValuesFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_fromRdfResourceValuesFunction.js";
 import { AbstractDiscriminatedUnionType_hashFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_hashFunction.js";
-import { AbstractDiscriminatedUnionType_schemaTypeExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_schemaTypeExpression.js";
 import { AbstractDiscriminatedUnionType_toJsonObjectFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_toJsonObjectFunction.js";
 import { AbstractDiscriminatedUnionType_toLoggableFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_toLoggableFunction.js";
 import { AbstractDiscriminatedUnionType_toRdfResourceValuesFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_toRdfResourceValuesFunction.js";
@@ -15,6 +14,7 @@ import { AbstractDiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpre
 import { AbstractDiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_valueSparqlWherePatternsFunction.js";
 import { AbstractCompoundType } from "./AbstractCompoundType.js";
 import type { ObjectType } from "./ObjectType.js";
+import { SchemaObject } from "./SchemaObject.js";
 import type { Type } from "./Type.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare abstract class AbstractDiscriminatedUnionType<MemberTypeT extends Type> extends AbstractCompoundType<AbstractDiscriminatedUnionType.Member<MemberTypeT>, MemberTypeT> {
@@ -25,7 +25,6 @@ export declare abstract class AbstractDiscriminatedUnionType<MemberTypeT extends
     protected fromJsonObjectFunctionExpression: typeof AbstractDiscriminatedUnionType_fromJsonObjectFunctionExpression;
     protected fromRdfResourceValuesFunctionExpression: typeof AbstractDiscriminatedUnionType_fromRdfResourceValuesFunctionExpression;
     protected hashFunctionExpression: typeof AbstractDiscriminatedUnionType_hashFunctionExpression;
-    protected schemaTypeExpression: typeof AbstractDiscriminatedUnionType_schemaTypeExpression;
     protected toJsonObjectFunctionExpression: typeof AbstractDiscriminatedUnionType_toJsonObjectFunctionExpression;
     protected toLoggableFunctionExpression: typeof AbstractDiscriminatedUnionType_toLoggableFunctionExpression;
     protected toRdfResourceValuesFunctionExpression: typeof AbstractDiscriminatedUnionType_toRdfResourceValuesFunctionExpression;
@@ -53,7 +52,7 @@ export declare abstract class AbstractDiscriminatedUnionType<MemberTypeT extends
     get jsTypes(): AbstractCompoundType<AbstractDiscriminatedUnionType.Member<MemberTypeT>, MemberTypeT>["jsTypes"];
     get members(): readonly AbstractDiscriminatedUnionType.Member<MemberTypeT>[];
     protected get inlineExpression(): Code;
-    protected get schemaInitializers(): readonly Code[];
+    get schema(): SchemaObject<SchemaObject.UserDefinedType>;
     private get conversionFunctionExpression();
     protected staticModuleDeclarations(name: string): Record<string, Code>;
     private readonly lazyMembers;

package/dist/generators/ts/AbstractDiscriminatedUnionType.js

@@ -16,7 +16,6 @@ import { AbstractDiscriminatedUnionType_fromRdfResourceValuesFunctionExpression
 import { AbstractDiscriminatedUnionType_hashFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_hashFunction.js";
 import { AbstractDiscriminatedUnionType_inferDiscriminant } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_inferDiscriminant.js";
 import { AbstractDiscriminatedUnionType_inlineExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_inlineExpression.js";
-import { AbstractDiscriminatedUnionType_schemaTypeExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_schemaTypeExpression.js";
 import { AbstractDiscriminatedUnionType_toJsonObjectFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_toJsonObjectFunction.js";
 import { AbstractDiscriminatedUnionType_toLoggableFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_toLoggableFunction.js";
 import { AbstractDiscriminatedUnionType_toRdfResourceValuesFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_toRdfResourceValuesFunction.js";
@@ -24,6 +23,7 @@ import { AbstractDiscriminatedUnionType_toStringFunctionExpression } from "./_Ab
 import { AbstractDiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_valueSparqlConstructTriplesFunction.js";
 import { AbstractDiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression } from "./_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_valueSparqlWherePatternsFunction.js";
 import { AbstractCompoundType } from "./AbstractCompoundType.js";
+import { SchemaObject } from "./SchemaObject.js";
 import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
 export class AbstractDiscriminatedUnionType extends AbstractCompoundType {
     discriminant;
@@ -33,7 +33,6 @@ export class AbstractDiscriminatedUnionType extends AbstractCompoundType {
     fromJsonObjectFunctionExpression = AbstractDiscriminatedUnionType_fromJsonObjectFunctionExpression;
     fromRdfResourceValuesFunctionExpression = AbstractDiscriminatedUnionType_fromRdfResourceValuesFunctionExpression;
     hashFunctionExpression = AbstractDiscriminatedUnionType_hashFunctionExpression;
-    schemaTypeExpression = AbstractDiscriminatedUnionType_schemaTypeExpression;
     toJsonObjectFunctionExpression = AbstractDiscriminatedUnionType_toJsonObjectFunctionExpression;
     toLoggableFunctionExpression = AbstractDiscriminatedUnionType_toLoggableFunctionExpression;
     toRdfResourceValuesFunctionExpression = AbstractDiscriminatedUnionType_toRdfResourceValuesFunctionExpression;
@@ -224,11 +223,27 @@ export class AbstractDiscriminatedUnionType extends AbstractCompoundType {
     get inlineExpression() {
         return AbstractDiscriminatedUnionType_inlineExpression.call(this);
     }
-    get schemaInitializers() {
-        return super.schemaInitializers.concat(code `members: { ${joinCode(this.members.map(({ discriminantValues, type, primaryDiscriminantValue }) => code `${literalOf(primaryDiscriminantValue)}: ${{
-            discriminantValues: discriminantValues,
-            type: type.schema,
-        }}`), { on: "," })} }`);
+    get schema() {
+        return new SchemaObject({
+            properties: {
+                ...super.schema.properties,
+                members: code `members: { ${joinCode(this.members.map(({ discriminantValues, type, primaryDiscriminantValue }) => code `${literalOf(primaryDiscriminantValue)}: ${{
+                    discriminantValues: discriminantValues,
+                    type: type.schema.expression,
+                }}`), { on: "," })} }`,
+            },
+            type: new SchemaObject.UserDefinedType({
+                members: {
+                    ...super.schema.type.members,
+                    members: code `members: { ${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `readonly ${literalOf(primaryDiscriminantValue)}: ${{
+                        discriminantValues: code `readonly (number | string)[]`,
+                        type: type.schema.type.expression,
+                    }}`), { on: ";" })} }`,
+                },
+                name: super.schema.type.name,
+            }),
+            variable: super.schema.variable,
+        });
     }
     get conversionFunctionExpression() {
         return AbstractDiscriminatedUnionType_conversionFunctionExpression.call(this);
@@ -266,6 +281,9 @@ __decorate([
 __decorate([
     Memoize()
 ], AbstractDiscriminatedUnionType.prototype, "inlineExpression", null);
+__decorate([
+    Memoize()
+], AbstractDiscriminatedUnionType.prototype, "schema", null);
 __decorate([
     Memoize()
 ], AbstractDiscriminatedUnionType.prototype, "conversionFunctionExpression", null);

package/dist/generators/ts/AbstractIntersectionType.d.ts

@@ -8,6 +8,7 @@ import { AbstractIntersectionType_valueSparqlConstructTriplesFunctionExpression
 import { AbstractIntersectionType_valueSparqlWherePatternsFunctionExpression } from "./_AbstractIntersectionType/AbstractIntersectionType_valueSparqlWherePatternsFunction.js";
 import { AbstractCompoundType } from "./AbstractCompoundType.js";
 import type { ObjectType } from "./ObjectType.js";
+import { SchemaObject } from "./SchemaObject.js";
 import type { Type } from "./Type.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare abstract class AbstractIntersectionType<MemberTypeT extends Type> extends AbstractCompoundType<AbstractIntersectionType.Member<MemberTypeT>, MemberTypeT> {
@@ -34,9 +35,8 @@ export declare abstract class AbstractIntersectionType<MemberTypeT extends Type>
     get graphqlType(): AbstractCompoundType.GraphqlType;
     get jsTypes(): AbstractCompoundType<AbstractIntersectionType.Member<MemberTypeT>, MemberTypeT>["jsTypes"];
     protected get inlineExpression(): Code;
-    protected get schemaInitializers(): readonly Code[];
+    get schema(): SchemaObject<SchemaObject.UserDefinedType>;
     protected filterTypeExpression(): Code;
-    protected schemaTypeExpression(): Code;
 }
 export declare namespace AbstractIntersectionType {
     type DiscriminatedType = AbstractCompoundType.DiscriminatedType;

package/dist/generators/ts/AbstractIntersectionType.js

@@ -15,6 +15,7 @@ import { AbstractIntersectionType_toStringFunctionExpression } from "./_Abstract
 import { AbstractIntersectionType_valueSparqlConstructTriplesFunctionExpression } from "./_AbstractIntersectionType/AbstractIntersectionType_valueSparqlConstructTriplesFunction.js";
 import { AbstractIntersectionType_valueSparqlWherePatternsFunctionExpression } from "./_AbstractIntersectionType/AbstractIntersectionType_valueSparqlWherePatternsFunction.js";
 import { AbstractCompoundType } from "./AbstractCompoundType.js";
+import { SchemaObject } from "./SchemaObject.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 export class AbstractIntersectionType extends AbstractCompoundType {
     equalsFunctionExpression = AbstractIntersectionType_equalsFunctionExpression;
@@ -55,18 +56,25 @@ export class AbstractIntersectionType extends AbstractCompoundType {
     get inlineExpression() {
         return joinCode(this.members.map((member) => member.type.expression), { on: " & " });
     }
-    get schemaInitializers() {
-        return super.schemaInitializers.concat(code `members: [${joinCode(this.members.map(({ type }) => type.schema), { on: "," })}] as const`);
+    get schema() {
+        return new SchemaObject({
+            properties: {
+                ...super.schema.properties,
+                members: code `members: [${joinCode(this.members.map(({ type }) => type.schema.expression), { on: "," })}] as const`,
+            },
+            type: new SchemaObject.UserDefinedType({
+                members: {
+                    ...super.schema.type.members,
+                    members: code `members: [${joinCode(this.members.map(({ type }) => type.schema.type.expression), { on: ", " })}]`,
+                },
+                name: super.schema.type.name,
+            }),
+            variable: super.schema.variable,
+        });
     }
     filterTypeExpression() {
         return joinCode(this.members.map(({ type }) => type.filterType), { on: " & " });
     }
-    schemaTypeExpression() {
-        return code `${{
-            kind: this.kind,
-            members: code `[${joinCode(this.members.map(({ type }) => type.schemaType), { on: ", " })}]`,
-        }}`;
-    }
 }
 __decorate([
     Memoize()
@@ -77,4 +85,7 @@ __decorate([
 __decorate([
     Memoize()
 ], AbstractIntersectionType.prototype, "inlineExpression", null);
+__decorate([
+    Memoize()
+], AbstractIntersectionType.prototype, "schema", null);
 //# sourceMappingURL=AbstractIntersectionType.js.map

package/dist/generators/ts/AbstractLazyType.d.ts

@@ -1,11 +1,12 @@
-import { AbstractType } from "./AbstractType.js";
+import { AbstractBuiltinType } from "./AbstractBuiltinType.js";
 import type { Callable } from "./Callable.js";
 import type { ObjectDiscriminatedUnionType } from "./ObjectDiscriminatedUnionType.js";
 import type { ObjectType } from "./ObjectType.js";
 import type { OptionType } from "./OptionType.js";
+import { SchemaObject } from "./SchemaObject.js";
 import type { SetType } from "./SetType.js";
 import { type Code } from "./ts-poet-wrapper.js";
-export declare abstract class AbstractLazyType<PartialTypeT extends AbstractLazyType.PartialTypeConstraint, ResolveTypeT extends AbstractLazyType.ResolveTypeConstraint> extends AbstractType {
+export declare abstract class AbstractLazyType<PartialTypeT extends AbstractLazyType.PartialTypeConstraint, ResolveTypeT extends AbstractLazyType.ResolveTypeConstraint> extends AbstractBuiltinType {
     protected abstract readonly partialItemType: AbstractLazyType.ItemTypeConstraint;
     protected abstract readonly resolveItemType: AbstractLazyType.ItemTypeConstraint;
     protected abstract readonly runtimeClass: {
@@ -13,40 +14,39 @@ export declare abstract class AbstractLazyType<PartialTypeT extends AbstractLazy
         readonly partialPropertyName: string;
         readonly rawName: Code;
     };
-    readonly discriminatedType: AbstractType["discriminatedType"];
+    readonly discriminatedType: AbstractBuiltinType["discriminatedType"];
     abstract readonly kind: "Lazy" | "LazyOption" | "LazySet";
     readonly mutable = false;
     readonly partialType: PartialTypeT;
     readonly resolveType: ResolveTypeT;
-    readonly validationFunction: AbstractType["validationFunction"];
+    readonly validationFunction: AbstractBuiltinType["validationFunction"];
     constructor({ partialType, resolveType, ...superParameters }: {
         partialType: PartialTypeT;
         resolveType: ResolveTypeT;
-    } & ConstructorParameters<typeof AbstractType>[0]);
+    } & ConstructorParameters<typeof AbstractBuiltinType>[0]);
     get equalsFunction(): Callable;
     get filterFunction(): Callable;
     get filterType(): Code;
-    get fromJsonObjectFunction(): AbstractType["fromJsonObjectFunction"];
-    get fromJsonValueFunction(): AbstractType["fromJsonValueFunction"];
+    get fromJsonObjectFunction(): AbstractBuiltinType["fromJsonObjectFunction"];
+    get fromJsonValueFunction(): AbstractBuiltinType["fromJsonValueFunction"];
     get fromRdfResourceValuesFunction(): Callable;
-    get graphqlType(): AbstractType.GraphqlType;
+    get graphqlType(): AbstractBuiltinType.GraphqlType;
     get hashFunction(): Callable;
     get inlineExpression(): Code;
-    get jsTypes(): readonly AbstractType.JsType[];
-    get jsonObjectType(): AbstractType["jsonObjectType"];
-    get jsonValueType(): AbstractType["jsonValueType"];
+    get jsTypes(): readonly AbstractBuiltinType.JsType[];
+    get jsonObjectType(): AbstractBuiltinType["jsonObjectType"];
+    get jsonValueType(): AbstractBuiltinType["jsonValueType"];
     get recursive(): boolean;
     get referencesNamedType(): boolean;
-    get schemaType(): Code;
-    get toJsonObjectFunction(): AbstractType["toJsonObjectFunction"];
-    get toJsonValueFunction(): AbstractType["toJsonValueFunction"];
-    get toRdfResourceValueTypes(): AbstractType["toRdfResourceValueTypes"];
+    get toJsonObjectFunction(): AbstractBuiltinType["toJsonObjectFunction"];
+    get toJsonValueFunction(): AbstractBuiltinType["toJsonValueFunction"];
+    get toRdfResourceValueTypes(): AbstractBuiltinType["toRdfResourceValueTypes"];
     get valueSparqlConstructTriplesFunction(): Callable;
     get valueSparqlWherePatternsFunction(): Callable;
-    protected get schemaInitializers(): readonly Code[];
-    toLoggableExpression({ variables, }: Parameters<AbstractType["toLoggableExpression"]>[0]): Code;
-    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
-    toStringExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
+    get schema(): SchemaObject<SchemaObject.AbstractType | SchemaObject.BuiltinType>;
+    toLoggableExpression({ variables, }: Parameters<AbstractBuiltinType["toLoggableExpression"]>[0]): Code;
+    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractBuiltinType["toRdfResourceValuesExpression"]>[0]): Code;
+    toStringExpression({ variables, }: Parameters<AbstractBuiltinType["toStringExpression"]>[0]): Code;
     protected abstract objectSetResolveExpression(parameters: {
         variables: {
             objectSet: Code;
@@ -75,10 +75,10 @@ export declare namespace AbstractLazyType {
     type ItemTypeConstraint = ObjectType | ObjectDiscriminatedUnionType;
     type PartialTypeConstraint = ItemTypeConstraint | OptionType<ItemTypeConstraint> | SetType<ItemTypeConstraint>;
     type ResolveTypeConstraint = PartialTypeConstraint;
-    type ConversionFunction = AbstractType.ConversionFunction;
-    type DiscriminatedType = AbstractType.DiscriminatedType;
+    type ConversionFunction = AbstractBuiltinType.ConversionFunction;
+    type DiscriminatedType = AbstractBuiltinType.DiscriminatedType;
     const GraphqlType: typeof import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
-    type GraphqlType = AbstractType.GraphqlType;
-    type JsonType = AbstractType.JsonType;
+    type GraphqlType = AbstractBuiltinType.GraphqlType;
+    type JsonType = AbstractBuiltinType.JsonType;
 }
 //# sourceMappingURL=AbstractLazyType.d.ts.map