@shaclmate/compiler 4.0.37 → 4.0.39

package/dist/generators/ts/AbstractUnionType.js

@@ -8,7 +8,6 @@ import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractType } from "./AbstractType.js";
-import { removeUndefined } from "./removeUndefined.js";
 import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
 export class AbstractUnionType extends AbstractType {
     discriminant;
@@ -25,14 +24,14 @@ export class AbstractUnionType extends AbstractType {
             let discriminantValues;
             invariant(this.discriminant.memberValues.length === members.length);
             switch (this.discriminant.kind) {
-                case "extrinsic":
+                case "Extrinsic":
                     discriminantValues = [this.discriminant.memberValues[memberI]];
                     break;
-                case "hybrid":
+                case "Hybrid":
                     discriminantValues =
                         this.discriminant.memberValues[memberI].ownValues;
                     break;
-                case "intrinsic": {
+                case "Intrinsic": {
                     // A member type's combined discriminant property values are its "own" values plus any descendant values that are
                     // not the "own" values of some other member type.
                     // So if you have type A, type B, and B inherits A, then
@@ -57,7 +56,7 @@ export class AbstractUnionType extends AbstractType {
                         .descendantValues.filter((value) => !memberOwnDiscriminantPropertyValues.has(value)));
                     break;
                 }
-                case "typeof":
+                case "Typeof":
                     discriminantValues = [this.discriminant.memberValues[memberI]];
                     break;
                 default:
@@ -66,13 +65,13 @@ export class AbstractUnionType extends AbstractType {
             invariant(discriminantValues.length > 0);
             const typeCheck = (json) => (instance) => {
                 const discriminant = this.discriminant; // To get type narrowing to work
-                if (discriminant.kind === "typeof") {
+                if (discriminant.kind === "Typeof") {
                     return code `(${joinCode(discriminantValues.map((discriminantValue) => code `typeof ${instance} === ${literalOf(discriminantValue)}`), { on: " || " })})`;
                 }
-                if (discriminant.kind === "intrinsic" && !json) {
+                if (discriminant.kind === "Intrinsic" && !json) {
                     switch (member.type.kind) {
-                        case "NamedObjectUnionType":
-                        case "NamedUnionType":
+                        case "NamedObjectUnion":
+                        case "NamedUnion":
                         case "NamedObjectType":
                             return code `${member.type.name}.is${member.type.name}(${instance})`;
                     }
@@ -85,45 +84,45 @@ export class AbstractUnionType extends AbstractType {
             return {
                 discriminantValues,
                 jsonType: member.type.jsonType({
-                    includeDiscriminantProperty: this.discriminant.kind === "intrinsic" ||
-                        (this.discriminant.kind === "hybrid" &&
-                            this.discriminant.memberValues[memberI].kind === "intrinsic"),
+                    includeDiscriminantProperty: this.discriminant.kind === "Intrinsic" ||
+                        (this.discriminant.kind === "Hybrid" &&
+                            this.discriminant.memberValues[memberI].kind === "Intrinsic"),
                 }).name,
                 jsonTypeCheck: typeCheck(true),
                 primaryDiscriminantValue: discriminantValues[0],
                 type: member.type,
                 typeCheck: typeCheck(false),
                 typeToJsonExpression: (valueVariable) => member.type.toJsonExpression({
-                    includeDiscriminantProperty: this.discriminant.kind === "intrinsic" ||
-                        (this.discriminant.kind === "hybrid" &&
-                            this.discriminant.memberValues[memberI].kind === "intrinsic"),
+                    includeDiscriminantProperty: this.discriminant.kind === "Intrinsic" ||
+                        (this.discriminant.kind === "Hybrid" &&
+                            this.discriminant.memberValues[memberI].kind === "Intrinsic"),
                     variables: { value: valueVariable },
                 }),
                 unwrap: (instance) => {
                     switch (this.discriminant.kind) {
-                        case "extrinsic":
+                        case "Extrinsic":
                             return code `${instance}.value`;
-                        case "hybrid":
+                        case "Hybrid":
                             return this.discriminant.memberValues[memberI].kind ===
-                                "intrinsic"
+                                "Intrinsic"
                                 ? instance
                                 : code `${instance}.value`;
-                        case "intrinsic":
-                        case "typeof":
+                        case "Intrinsic":
+                        case "Typeof":
                             return instance;
                     }
                 },
                 wrap: (instance) => {
                     switch (this.discriminant.kind) {
-                        case "extrinsic":
+                        case "Extrinsic":
                             return code `{ ${this.discriminant.name}: ${literalOf(discriminantValues[0])} as const, value: ${instance} }`;
-                        case "hybrid":
+                        case "Hybrid":
                             return this.discriminant.memberValues[memberI].kind ===
-                                "intrinsic"
+                                "Intrinsic"
                                 ? instance
                                 : code `{ ${this.discriminant.name}: ${literalOf(discriminantValues[0])} as const, value: ${instance} }`;
-                        case "intrinsic":
-                        case "typeof":
+                        case "Intrinsic":
+                        case "Typeof":
                             return instance;
                     }
                 },
@@ -133,7 +132,7 @@ export class AbstractUnionType extends AbstractType {
     get conversionFunction() {
         return Maybe.of({
             code: code `${this.reusables.snippets.identityConversionFunction}`,
-            sourceTypes: this.discriminant.kind === "typeof"
+            sourceTypes: this.discriminant.kind === "Typeof"
                 ? this.members.map(({ primaryDiscriminantValue, type }) => ({
                     name: type.name,
                     typeof: primaryDiscriminantValue,
@@ -148,28 +147,28 @@ export class AbstractUnionType extends AbstractType {
     }
     get discriminantProperty() {
         switch (this.discriminant.kind) {
-            case "extrinsic":
+            case "Extrinsic":
                 return Maybe.of({
                     descendantValues: [],
                     jsonName: this.discriminant.jsonName,
                     ownValues: this.discriminant.memberValues,
                     name: this.discriminant.name,
                 });
-            case "hybrid":
+            case "Hybrid":
                 return Maybe.of({
                     descendantValues: [],
                     jsonName: this.discriminant.jsonName,
                     ownValues: this.discriminant.memberValues.flatMap((_) => _.ownValues),
                     name: "termType",
                 });
-            case "intrinsic":
+            case "Intrinsic":
                 return Maybe.of({
                     descendantValues: this.discriminant.memberValues.flatMap((_) => _.descendantValues),
                     jsonName: this.discriminant.jsonName,
                     name: this.discriminant.name,
                     ownValues: this.discriminant.memberValues.flatMap((_) => _.ownValues),
                 });
-            case "typeof":
+            case "Typeof":
                 return Maybe.empty();
             default:
                 throw this.discriminant;
@@ -181,16 +180,12 @@ export class AbstractUnionType extends AbstractType {
     get mutable() {
         return this.members.some((member) => member.type.mutable);
     }
-    get schema() {
-        return code `${removeUndefined(this.schemaObject)}`;
+    get referencesObjectType() {
+        return this.members.some((member) => member.type.referencesObjectType);
     }
     get schemaType() {
-        invariant(this.kind.endsWith("Type"));
         return code `${{
-            // discriminant: {
-            //   kind: '"extrinsic" | "intrinsic" | "typeof"',
-            // },
-            kind: code `${literalOf(this.kind.substring(0, this.kind.length - "Type".length))}`,
+            kind: this.kind,
             members: code `{ ${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `readonly ${literalOf(primaryDiscriminantValue)}: ${{
                 discriminantValues: code `readonly (number | string)[]`,
                 type: type.schemaType,
@@ -288,9 +283,9 @@ ${joinCode(this.members.map(({ jsonType, jsonTypeCheck, type, unwrap, wrap }) =>
                     resourceValues: code `valueAsValues`,
                 },
             });
-            if (this.discriminant.kind === "extrinsic" ||
-                (this.discriminant.kind === "hybrid" &&
-                    this.discriminant.memberValues[memberI].kind === "extrinsic")) {
+            if (this.discriminant.kind === "Extrinsic" ||
+                (this.discriminant.kind === "Hybrid" &&
+                    this.discriminant.memberValues[memberI].kind === "Extrinsic")) {
                 typeExpression = code `${typeExpression}.map(values => values.map(value => ({ ${this.discriminant.name}: ${literalOf(primaryDiscriminantValue)} as const, value }) as (${this.name})))`;
             }
             typeExpression = code `(${typeExpression} as ${this.reusables.imports.Either}<Error, ${this.reusables.imports.Resource}.Values<${this.name}>>)`;
@@ -311,14 +306,14 @@ ${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeChe
     get inlineJsonSchema() {
         const discriminant = this.discriminant; // To get type narrowing to work
         switch (discriminant.kind) {
-            case "extrinsic":
+            case "Extrinsic":
                 return code `${this.reusables.imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `${this.reusables.imports.z}.object({ ${discriminant.name}: ${this.reusables.imports.z}.literal(${literalOf(primaryDiscriminantValue)}), value: ${type.jsonSchema({ context: "type" })} })`), { on: "," })}]).readonly()`;
-            case "hybrid":
+            case "Hybrid":
                 return code `${this.reusables.imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.members.map(({ primaryDiscriminantValue, type }, memberI) => {
                     switch (discriminant.memberValues[memberI].kind) {
-                        case "extrinsic":
+                        case "Extrinsic":
                             return code `${this.reusables.imports.z}.object({ ${discriminant.name}: ${this.reusables.imports.z}.literal(${literalOf(primaryDiscriminantValue)}), value: ${type.jsonSchema({ context: "type" })} })`;
-                        case "intrinsic":
+                        case "Intrinsic":
                             return type.jsonSchema({
                                 includeDiscriminantProperty: true,
                                 context: "type",
@@ -327,12 +322,12 @@ ${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeChe
                             throw new Error();
                     }
                 }), { on: "," })}]).readonly()`;
-            case "intrinsic":
+            case "Intrinsic":
                 return code `${this.reusables.imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.members.map(({ type }) => type.jsonSchema({
                     includeDiscriminantProperty: true,
                     context: "type",
                 })), { on: "," })}]).readonly()`;
-            case "typeof":
+            case "Typeof":
                 return code `${this.reusables.imports.z}.union([${joinCode(this.members.map(({ type }) => type.jsonSchema({ context: "type" })), { on: "," })}]).readonly()`;
             default:
                 throw discriminant;
@@ -341,21 +336,21 @@ ${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeChe
     get inlineJsonType() {
         const discriminant = this.discriminant; // To get type narrowing to work
         switch (discriminant.kind) {
-            case "extrinsic":
+            case "Extrinsic":
                 return new AbstractType.JsonType(code `(${joinCode(this.members.map(({ jsonType, primaryDiscriminantValue }) => code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${jsonType} }`), { on: "|" })})`);
-            case "hybrid":
+            case "Hybrid":
                 return new AbstractType.JsonType(code `(${joinCode(this.members.map(({ jsonType, primaryDiscriminantValue }, memberI) => {
                     switch (discriminant.memberValues[memberI].kind) {
-                        case "extrinsic":
+                        case "Extrinsic":
                             return code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${jsonType} }`;
-                        case "intrinsic":
+                        case "Intrinsic":
                             return code `${jsonType}`;
                         default:
                             throw new Error();
                     }
                 }), { on: "|" })})`);
-            case "intrinsic":
-            case "typeof":
+            case "Intrinsic":
+            case "Typeof":
                 return new AbstractType.JsonType(joinCode(this.members.map(({ jsonType }) => code `${jsonType}`), { on: "|" }));
             default:
                 throw discriminant;
@@ -364,24 +359,24 @@ ${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeChe
     get inlineName() {
         const discriminant = this.discriminant; // To get type narrowing to work
         switch (discriminant.kind) {
-            case "extrinsic":
+            case "Extrinsic":
                 return code `(${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${type.name} }`), { on: "|" })})`;
-            case "hybrid":
+            case "Hybrid":
                 return code `(${joinCode(this.members.map(({ primaryDiscriminantValue, type }, memberI) => {
                     switch (discriminant.memberValues[memberI].kind) {
-                        case "extrinsic":
+                        case "Extrinsic":
                             return code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${type.name} }`;
-                        case "intrinsic":
+                        case "Intrinsic":
                             return code `${type.name}`;
                         default:
                             throw new Error();
                     }
                 }), { on: "|" })})`;
-            case "intrinsic":
+            case "Intrinsic":
                 // If every type shares a discriminant (e.g., RDF/JS "termType" or generated NamedObjectType "type"),
                 // just join their names with "|"
                 return code `(${joinCode(this.members.map(({ type }) => code `${type.name}`), { on: "|" })})`;
-            case "typeof":
+            case "Typeof":
                 // The type.name may include literal values, but they should still be unambiguous with other member types since the typeofs
                 // of the different member types are known to be different.
                 return code `(${joinCode(this.members.map(({ type }) => code `${type.name}`), { on: "|" })})`;
@@ -458,14 +453,11 @@ unionPatterns.push({ patterns: ${type.valueSparqlWherePatternsFunction}({ ...oth
   return [{ patterns: unionPatterns, type: "union" }];
 }) satisfies ${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}>)`;
     }
-    get schemaObject() {
-        return {
-            ...super.schemaObject,
-            members: code `{ ${joinCode(this.members.map(({ discriminantValues, type, primaryDiscriminantValue }) => code `${literalOf(primaryDiscriminantValue)}: ${{
-                discriminantValues: discriminantValues,
-                type: type.schema,
-            }}`), { on: "," })} }`,
-        };
+    get schemaInitializers() {
+        return super.schemaInitializers.concat(code `members: { ${joinCode(this.members.map(({ discriminantValues, type, primaryDiscriminantValue }) => code `${literalOf(primaryDiscriminantValue)}: ${{
+            discriminantValues: discriminantValues,
+            type: type.schema,
+        }}`), { on: "," })} }`);
     }
     jsonUiSchemaElement() {
         return Maybe.empty();
@@ -484,9 +476,6 @@ __decorate([
 __decorate([
     Memoize()
 ], AbstractUnionType.prototype, "mutable", null);
-__decorate([
-    Memoize()
-], AbstractUnionType.prototype, "schema", null);
 __decorate([
     Memoize()
 ], AbstractUnionType.prototype, "toRdfResourceValueTypes", null);
@@ -516,11 +505,11 @@ __decorate([
 ], AbstractUnionType.prototype, "inlineValueSparqlWherePatternsFunction", null);
 function termTypes(type) {
     switch (type.kind) {
-        case "BlankNodeType":
-        case "IriType":
-        case "IdentifierType":
-        case "LiteralType":
-        case "TermType":
+        case "BlankNode":
+        case "Iri":
+        case "Identifier":
+        case "Literal":
+        case "Term":
             return type.termTypes;
         default:
             return emptyTermTypesSet;
@@ -534,7 +523,7 @@ export var Discriminant;
         if (members.some((member) => member.discriminantValue.isJust())) {
             return {
                 jsonName: "type",
-                kind: "extrinsic",
+                kind: "Extrinsic",
                 memberValues: members.map((member, memberI) => member.discriminantValue.orDefault(memberI)),
                 name: "type",
             };
@@ -566,7 +555,7 @@ export var Discriminant;
             if (inlineDiscriminantProperty) {
                 return {
                     jsonName: inlineDiscriminantProperty.jsonName,
-                    kind: "intrinsic",
+                    kind: "Intrinsic",
                     memberValues,
                     name: inlineDiscriminantProperty.name,
                 };
@@ -583,7 +572,7 @@ export var Discriminant;
             if (memberTypeofsSet.size === memberTypes.length) {
                 return {
                     memberValues: memberTypes.flatMap((memberType) => memberType.typeofs),
-                    kind: "typeof",
+                    kind: "Typeof",
                 };
             }
         }
@@ -606,17 +595,17 @@ export var Discriminant;
             }
             return {
                 jsonName: "termType",
-                kind: "hybrid",
+                kind: "Hybrid",
                 memberValues: memberTypes.map((memberType, memberTypeI) => {
                     const memberTermTypes = termTypes(memberType);
                     if (memberTermTypes.size > 0) {
                         return {
-                            kind: "intrinsic",
+                            kind: "Intrinsic",
                             ownValues: [...memberTermTypes],
                         };
                     }
                     return {
-                        kind: "extrinsic",
+                        kind: "Extrinsic",
                         ownValues: extrinsicMemberTypeNamesSet.size === extrinsicMemberTypeCount
                             ? [memberType.name]
                             : [memberTypeI.toString()],
@@ -649,7 +638,7 @@ export var Discriminant;
             invariant(memberValues.length === memberTypes.length);
             return {
                 jsonName: "type",
-                kind: "extrinsic",
+                kind: "Extrinsic",
                 name: "type",
                 memberValues: memberValues,
             };

package/dist/generators/ts/AnonymousUnionType.d.ts

@@ -6,7 +6,7 @@ import { type Code } from "./ts-poet-wrapper.js";
 export declare class AnonymousUnionType extends AbstractUnionType<Type> {
     readonly declaration: Maybe<Code>;
     readonly graphqlArgs: AbstractType["graphqlArgs"];
-    readonly kind = "AnonymousUnionType";
+    readonly kind = "AnonymousUnion";
     get equalsFunction(): Code;
     get filterFunction(): Code;
     get filterType(): Code;

package/dist/generators/ts/AnonymousUnionType.js

@@ -4,7 +4,7 @@ import { code } from "./ts-poet-wrapper.js";
 export class AnonymousUnionType extends AbstractUnionType {
     declaration = Maybe.empty();
     graphqlArgs = Maybe.empty();
-    kind = "AnonymousUnionType";
+    kind = "AnonymousUnion";
     get equalsFunction() {
         return this.inlineEqualsFunction;
     }

package/dist/generators/ts/BigDecimalType.d.ts

@@ -8,7 +8,7 @@ export declare class BigDecimalType extends AbstractLiteralType {
     readonly filterFunction: Code;
     readonly filterType: Code;
     readonly hashFunction: Code;
-    readonly kind = "BigDecimalType";
+    readonly kind = "BigDecimal";
     readonly schemaType: Code;
     readonly valueSparqlWherePatternsFunction: Code;
     get graphqlType(): import("./AbstractType.js").AbstractType.GraphqlType;

package/dist/generators/ts/BigDecimalType.js

@@ -14,7 +14,7 @@ export class BigDecimalType extends AbstractLiteralType {
     filterFunction = code `${this.reusables.snippets.filterBigDecimal}`;
     filterType = code `${this.reusables.snippets.NumericFilter}<${this.reusables.imports.BigDecimal}>`;
     hashFunction = code `${this.reusables.snippets.hashBigDecimal}`;
-    kind = "BigDecimalType";
+    kind = "BigDecimal";
     schemaType = code `${this.reusables.snippets.NumericSchema}<${this.reusables.imports.BigDecimal}>`;
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.bigDecimalSparqlWherePatterns}`;
     get graphqlType() {

package/dist/generators/ts/BigIntType.d.ts

@@ -2,7 +2,7 @@ import type { Literal } from "@rdfjs/types";
 import { AbstractNumericType } from "./AbstractNumericType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class BigIntType extends AbstractNumericType<bigint> {
-    readonly kind = "BigIntType";
+    readonly kind = "BigInt";
     readonly typeofs: "bigint"[];
     get graphqlType(): import("./AbstractType.js").AbstractType.GraphqlType;
     fromJsonExpression({ variables, }: Parameters<AbstractNumericType<bigint>["fromJsonExpression"]>[0]): Code;

package/dist/generators/ts/BigIntType.js

@@ -9,7 +9,7 @@ import { Memoize } from "typescript-memoize";
 import { AbstractNumericType } from "./AbstractNumericType.js";
 import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
 export class BigIntType extends AbstractNumericType {
-    kind = "BigIntType";
+    kind = "BigInt";
     typeofs = ["bigint"];
     get graphqlType() {
         return new AbstractNumericType.GraphqlType(code `${this.reusables.imports.GraphQLBigInt}`, this.reusables);

package/dist/generators/ts/BlankNodeType.d.ts

@@ -7,7 +7,7 @@ export declare class BlankNodeType extends AbstractIdentifierType<BlankNode> {
     readonly filterFunction: Code;
     readonly filterType: Code;
     readonly parseFunction: Code;
-    readonly kind = "BlankNodeType";
+    readonly kind = "BlankNode";
     readonly name: Code;
     readonly nodeKinds: ReadonlySet<"BlankNode">;
     readonly schemaType: Code;

package/dist/generators/ts/BlankNodeType.js

@@ -25,7 +25,7 @@ export class BlankNodeType extends AbstractIdentifierType {
     filterFunction = code `${this.reusables.snippets.filterBlankNode}`;
     filterType = code `${this.reusables.snippets.BlankNodeFilter}`;
     parseFunction = code `${this.reusables.snippets.parseBlankNode};`;
-    kind = "BlankNodeType";
+    kind = "BlankNode";
     name = code `${this.reusables.imports.BlankNode}`;
     nodeKinds = nodeKinds;
     schemaType = code `${this.reusables.snippets.BlankNodeSchema}`;

package/dist/generators/ts/BooleanType.d.ts

@@ -6,7 +6,7 @@ export declare class BooleanType extends AbstractPrimitiveType<boolean> {
     readonly filterType: Code;
     readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
     readonly hashFunction: Code;
-    readonly kind = "BooleanType";
+    readonly kind = "Boolean";
     readonly schemaType: Code;
     readonly typeofs: "boolean"[];
     readonly valueSparqlWherePatternsFunction: Code;

package/dist/generators/ts/BooleanType.js

@@ -13,8 +13,8 @@ export class BooleanType extends AbstractPrimitiveType {
     filterType = code `${this.reusables.snippets.BooleanFilter}`;
     graphqlType = new AbstractPrimitiveType.GraphqlType(code `${this.reusables.imports.GraphQLBoolean}`, this.reusables);
     hashFunction = code `${this.reusables.snippets.hashBoolean}`;
-    kind = "BooleanType";
-    schemaType = code `${this.reusables.snippets.BooleanSchema}`;
+    kind = "Boolean";
+    schemaType = code `${this.reusables.snippets.BooleanSchema}<${this.name}>`;
     typeofs = ["boolean"];
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.booleanSparqlWherePatterns}`;
     get name() {

package/dist/generators/ts/DateTimeType.d.ts

@@ -4,7 +4,7 @@ import { type Code } from "./ts-poet-wrapper.js";
 export declare class DateTimeType extends AbstractDateType {
     readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
     readonly hashFunction: Code;
-    readonly kind = "DateTimeType";
+    readonly kind = "DateTime";
     jsonSchema(_parameters: Parameters<AbstractDateType["jsonSchema"]>[0]): Code;
     literalExpression(literal: Date | Literal): Code;
     toJsonExpression({ variables, }: Parameters<AbstractDateType["toJsonExpression"]>[0]): Code;

package/dist/generators/ts/DateTimeType.js

@@ -4,7 +4,7 @@ import { code } from "./ts-poet-wrapper.js";
 export class DateTimeType extends AbstractDateType {
     graphqlType = new DateTimeType.GraphqlType(code `${this.reusables.imports.GraphQLDateTime}`, this.reusables);
     hashFunction = code `${this.reusables.snippets.hashDateTime}`;
-    kind = "DateTimeType";
+    kind = "DateTime";
     jsonSchema(_parameters) {
         return code `${this.reusables.imports.z}.iso.datetime()`;
     }

package/dist/generators/ts/DateType.d.ts

@@ -5,7 +5,7 @@ import { type Code } from "./ts-poet-wrapper.js";
 export declare class DateType extends AbstractDateType {
     readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
     readonly hashFunction: Code;
-    readonly kind = "DateType";
+    readonly kind = "Date";
     jsonSchema(_parameters: Parameters<DateTimeType["jsonSchema"]>[0]): Code;
     literalExpression(literal: Date | Literal): Code;
     toJsonExpression({ variables, }: Parameters<AbstractDateType["toJsonExpression"]>[0]): Code;

package/dist/generators/ts/DateType.js

@@ -5,7 +5,7 @@ import { code } from "./ts-poet-wrapper.js";
 export class DateType extends AbstractDateType {
     graphqlType = new DateTimeType.GraphqlType(code `${this.reusables.imports.GraphQLDate}`, this.reusables);
     hashFunction = code `${this.reusables.snippets.hashDate}`;
-    kind = "DateType";
+    kind = "Date";
     jsonSchema(_parameters) {
         return code `${this.reusables.imports.z}.iso.date()`;
     }

package/dist/generators/ts/DefaultValueType.d.ts

@@ -9,7 +9,7 @@ export declare class DefaultValueType<ItemTypeT extends DefaultValueType.ItemTyp
     readonly defaultValue: Literal | NamedNode;
     readonly discriminantProperty: Maybe<AbstractType.DiscriminantProperty>;
     readonly graphqlArgs: AbstractType["graphqlArgs"];
-    readonly kind = "DefaultValueType";
+    readonly kind = "DefaultValue";
     readonly typeofs: "object"[];
     readonly validationFunction: Maybe<Code>;
     constructor({ defaultValue, ...superParameters }: {
@@ -26,11 +26,7 @@ export declare class DefaultValueType<ItemTypeT extends DefaultValueType.ItemTyp
     get schemaType(): Code;
     get valueSparqlConstructTriplesFunction(): Code;
     get valueSparqlWherePatternsFunction(): Code;
-    protected get schemaObject(): {
-        defaultValue: Code;
-        item: Code;
-        kind: Code;
-    };
+    protected get schemaInitializers(): Code[];
     private get defaultValueExpression();
     fromJsonExpression(parameters: Parameters<AbstractType["fromJsonExpression"]>[0]): Code;
     fromRdfResourceValuesExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["fromRdfResourceValuesExpression"]>[0]): Code;

package/dist/generators/ts/DefaultValueType.js

@@ -13,7 +13,7 @@ export class DefaultValueType extends AbstractContainerType {
     defaultValue;
     discriminantProperty = Maybe.empty();
     graphqlArgs = Maybe.empty();
-    kind = "DefaultValueType";
+    kind = "DefaultValue";
     typeofs = ["object"];
     validationFunction = this.itemType.validationFunction;
     constructor({ defaultValue, ...superParameters }) {
@@ -62,24 +62,21 @@ export class DefaultValueType extends AbstractContainerType {
     get valueSparqlWherePatternsFunction() {
         return code `${this.reusables.snippets.defaultValueSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction})`;
     }
-    get schemaObject() {
-        return {
-            ...super.schemaObject,
-            defaultValue: this.defaultValueExpression,
-        };
+    get schemaInitializers() {
+        return super.schemaInitializers.concat(code `defaultValue: ${this.defaultValueExpression}`);
     }
     get defaultValueExpression() {
         switch (this.itemType.kind) {
-            case "IdentifierType":
-            case "IriType":
-            case "LiteralType":
-            case "TermType":
+            case "Identifier":
+            case "Iri":
+            case "Literal":
+            case "Term":
                 return this.rdfjsTermExpression(this.defaultValue);
-            case "AnonymousUnionType":
-            case "ListType":
+            case "AnonymousUnion":
+            case "List":
             case "NamedObjectType":
-            case "NamedObjectUnionType":
-            case "NamedUnionType":
+            case "NamedObjectUnion":
+            case "NamedUnion":
                 throw new RangeError(`not implemented ${this.itemType.kind}`);
         }
         invariant(this.defaultValue.termType === "Literal");
@@ -136,7 +133,7 @@ __decorate([
 ], DefaultValueType.prototype, "defaultValueExpression", null);
 (function (DefaultValueType) {
     function isItemType(type) {
-        if (type.kind === "BlankNodeType") {
+        if (type.kind === "BlankNode") {
             return false;
         }
         return AbstractContainerType.isItemType(type);

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

@@ -2,7 +2,7 @@ import type { Literal } from "@rdfjs/types";
 import { AbstractNumericType } from "./AbstractNumericType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class FloatType extends AbstractNumericType<number> {
-    readonly kind = "FloatType";
+    readonly kind = "Float";
     readonly typeofs: "number"[];
     get graphqlType(): import("./AbstractType.js").AbstractType.GraphqlType;
     literalExpression(literal: Literal | number): Code;

package/dist/generators/ts/FloatType.js

@@ -9,7 +9,7 @@ import { Memoize } from "typescript-memoize";
 import { AbstractNumericType } from "./AbstractNumericType.js";
 import { code } from "./ts-poet-wrapper.js";
 export class FloatType extends AbstractNumericType {
-    kind = "FloatType";
+    kind = "Float";
     typeofs = ["number"];
     get graphqlType() {
         return new AbstractNumericType.GraphqlType(code `${this.reusables.imports.GraphQLFloat}`, this.reusables);

package/dist/generators/ts/IdentifierType.d.ts

@@ -8,7 +8,7 @@ export declare class IdentifierType extends AbstractIdentifierType<BlankNode | N
     readonly filterFunction: Code;
     readonly filterType: Code;
     readonly parseFunction: Code;
-    readonly kind = "IdentifierType";
+    readonly kind = "Identifier";
     readonly name: Code;
     readonly nodeKinds: ReadonlySet<IdentifierNodeKind>;
     readonly schemaType: Code;