@shaclmate/compiler 4.0.98 → 4.0.100

package/dist/generators/ts/_ObjectType/ObjectType_IdentifierProperty.js

@@ -9,6 +9,7 @@ import { rdf } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
+import { SchemaObject } from "../SchemaObject.js";
 import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
 import { ObjectType_AbstractProperty } from "./ObjectType_AbstractProperty.js";
 export class ObjectType_IdentifierProperty extends ObjectType_AbstractProperty {
@@ -78,13 +79,23 @@ export class ObjectType_IdentifierProperty extends ObjectType_AbstractProperty {
         });
     }
     get schema() {
-        return Maybe.of(code `{ ${joinCode([code `kind: ${literalOf(this.kind)}`, code `type: ${this.type.schema}`], { on: ", " })} }`);
-    }
-    get schemaType() {
-        return Maybe.of(code `{ ${joinCode([
-            code `readonly kind: ${literalOf(this.kind)}`,
-            code `readonly type: ${this.type.schemaType}`,
-        ], { on: ", " })} }`);
+        return Maybe.of(this._schema);
+    }
+    get _schema() {
+        return new SchemaObject({
+            properties: {
+                kind: code `kind: ${literalOf(this.kind)}`,
+                type: code `type: ${this.type.schema.expression}`,
+            },
+            type: new SchemaObject.UserDefinedType({
+                members: {
+                    kind: code `readonly kind: ${literalOf(this.kind)}`,
+                    type: code `readonly type: ${this.type.schema.type.expression}`,
+                },
+                name: Maybe.empty(),
+            }),
+            variable: this.schemaVariable,
+        });
     }
     get typeExpression() {
         return this.objectType.name
@@ -92,9 +103,9 @@ export class ObjectType_IdentifierProperty extends ObjectType_AbstractProperty {
             .orDefault(this.type.expression);
     }
     get typeSchemaVariable() {
-        return this.objectType.name
-            .map((name) => code `${name}.schema.properties.${this.name}.type`)
-            .orDefaultLazy(() => this.type.schema);
+        return this.schemaVariable
+            .map((schemaVariable) => code `${schemaVariable}.type`)
+            .orDefault(this.type.schema.expression);
     }
     createInitializer({ variables, }) {
         const nodeKinds = this.type.nodeKinds;
@@ -203,7 +214,16 @@ __decorate([
 __decorate([
     Memoize()
 ], ObjectType_IdentifierProperty.prototype, "jsonObjectMember", null);
+__decorate([
+    Memoize()
+], ObjectType_IdentifierProperty.prototype, "schema", null);
+__decorate([
+    Memoize()
+], ObjectType_IdentifierProperty.prototype, "_schema", null);
 __decorate([
     Memoize()
 ], ObjectType_IdentifierProperty.prototype, "typeExpression", null);
+__decorate([
+    Memoize()
+], ObjectType_IdentifierProperty.prototype, "typeSchemaVariable", null);
 //# sourceMappingURL=ObjectType_IdentifierProperty.js.map

package/dist/generators/ts/_ObjectType/ObjectType_RdfTypeProperty.d.ts

@@ -1,5 +1,6 @@
 import type { NamedNode } from "@rdfjs/types";
 import { Maybe } from "purify-ts";
+import { SchemaObject } from "../SchemaObject.js";
 import { type Code } from "../ts-poet-wrapper.js";
 import { ObjectType_AbstractProperty } from "./ObjectType_AbstractProperty.js";
 export declare class ObjectType_RdfTypeProperty extends ObjectType_AbstractProperty {
@@ -17,9 +18,9 @@ export declare class ObjectType_RdfTypeProperty extends ObjectType_AbstractPrope
         fromRdfType: NamedNode;
         toRdfTypes: readonly NamedNode[];
     } & Omit<ConstructorParameters<typeof ObjectType_AbstractProperty>[0], "name">);
-    get schema(): Maybe<Code>;
     get jsonObjectMember(): ObjectType_AbstractProperty["jsonObjectMember"];
-    get schemaType(): Maybe<Code>;
+    get schema(): Maybe<SchemaObject<SchemaObject.UserDefinedType>>;
+    private get _schema();
     createInitializer(): Maybe<Code>;
     equalsExpression(): Maybe<Code>;
     filterExpression(): Maybe<Code>;

package/dist/generators/ts/_ObjectType/ObjectType_RdfTypeProperty.js

@@ -7,6 +7,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { rdf, rdfs } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
+import { SchemaObject } from "../SchemaObject.js";
 import { arrayOf, code, joinCode, literalOf, } from "../ts-poet-wrapper.js";
 import { ObjectType_AbstractProperty } from "./ObjectType_AbstractProperty.js";
 export class ObjectType_RdfTypeProperty extends ObjectType_AbstractProperty {
@@ -29,9 +30,6 @@ export class ObjectType_RdfTypeProperty extends ObjectType_AbstractProperty {
         this.fromRdfType = fromRdfType;
         this.toRdfTypes = toRdfTypes;
     }
-    get schema() {
-        return Maybe.of(code `${{ fromRdfType: this.rdfjsTermExpression(this.fromRdfType), kind: this.kind, toRdfTypes: this.toRdfTypes.map((toRdfType) => this.rdfjsTermExpression(toRdfType)) }}`);
-    }
     get jsonObjectMember() {
         return Maybe.of({
             description: Maybe.empty(),
@@ -47,8 +45,26 @@ export class ObjectType_RdfTypeProperty extends ObjectType_AbstractProperty {
             uiSchemaElement: Maybe.empty(),
         });
     }
-    get schemaType() {
-        return Maybe.of(code `${{ fromRdfType: code `${this.reusables.imports.NamedNode}`, kind: this.kind, toRdfTypes: code `readonly ${this.reusables.imports.NamedNode}[]` }}`);
+    get schema() {
+        return Maybe.of(this._schema);
+    }
+    get _schema() {
+        return new SchemaObject({
+            properties: {
+                fromRdfType: code `fromRdfType: ${this.rdfjsTermExpression(this.fromRdfType)}`,
+                kind: code `kind: ${literalOf(this.kind)}`,
+                toRdfTypes: code `toRdfTypes: ${arrayOf(...this.toRdfTypes.map((toRdfType) => this.rdfjsTermExpression(toRdfType)))}`,
+            },
+            type: new SchemaObject.UserDefinedType({
+                members: {
+                    fromRdfType: code `fromRdfType: ${this.reusables.imports.NamedNode}`,
+                    kind: code `kind: ${literalOf(this.kind)}`,
+                    toRdfTypes: code `toRdfTypes: readonly ${this.reusables.imports.NamedNode}[]`,
+                },
+                name: Maybe.empty(),
+            }),
+            variable: this.schemaVariable,
+        });
     }
     createInitializer() {
         return Maybe.empty();
@@ -63,7 +79,7 @@ export class ObjectType_RdfTypeProperty extends ObjectType_AbstractProperty {
         return Maybe.empty();
     }
     fromRdfResourceValuesInitializer({ variables, }) {
-        return Maybe.of(code `${this.name}: !${variables.ignoreRdfType} ? ${this.reusables.snippets.ensureRdfResourceType}(${variables.focusResource}, ${arrayOf(code `(${this.schemaVariable}).fromRdfType`)}, ${{ graph: variables.graph }}) : ${this.reusables.imports.Right}(true as const)`);
+        return Maybe.of(code `${this.name}: !${variables.ignoreRdfType} ? ${this.reusables.snippets.ensureRdfResourceType}(${variables.focusResource}, ${arrayOf(code `(${this._schema.expression}).fromRdfType`)}, ${{ graph: variables.graph }}) : ${this.reusables.imports.Right}(true as const)`);
     }
     hashStatements() {
         return [];
@@ -122,7 +138,7 @@ type: "optional" as const
         return [
             code `\
 if (!${variables.ignoreRdfType}) {
-  ${variables.resource}.add(${this.rdfjsTermExpression(rdf.type)}, ${this.schemaVariable}.toRdfTypes, ${variables.graph});
+  ${variables.resource}.add(${this.rdfjsTermExpression(rdf.type)}, ${this._schema.expression}.toRdfTypes, ${variables.graph});
 }`,
         ];
     }
@@ -132,13 +148,13 @@ if (!${variables.ignoreRdfType}) {
 }
 __decorate([
     Memoize()
-], ObjectType_RdfTypeProperty.prototype, "schema", null);
+], ObjectType_RdfTypeProperty.prototype, "jsonObjectMember", null);
 __decorate([
     Memoize()
-], ObjectType_RdfTypeProperty.prototype, "jsonObjectMember", null);
+], ObjectType_RdfTypeProperty.prototype, "schema", null);
 __decorate([
     Memoize()
-], ObjectType_RdfTypeProperty.prototype, "schemaType", null);
+], ObjectType_RdfTypeProperty.prototype, "_schema", null);
 __decorate([
     Memoize()
 ], ObjectType_RdfTypeProperty.prototype, "equalsExpression", null);

package/dist/generators/ts/_ObjectType/ObjectType_ShaclProperty.d.ts

@@ -1,5 +1,6 @@
 import type { PropertyPath } from "@rdfx/resource";
 import { Maybe } from "purify-ts";
+import { SchemaObject } from "../SchemaObject.js";
 import type { Type } from "../Type.js";
 import { type Code } from "../ts-poet-wrapper.js";
 import { ObjectType_AbstractProperty } from "./ObjectType_AbstractProperty.js";
@@ -37,8 +38,8 @@ export declare class ObjectType_ShaclProperty<TypeT extends Type> extends Object
     get graphqlField(): ObjectType_AbstractProperty["graphqlField"];
     get hashFunctionParameter(): Maybe<Code>;
     get jsonObjectMember(): ObjectType_AbstractProperty["jsonObjectMember"];
-    get schema(): Maybe<Code>;
-    get schemaType(): Maybe<Code>;
+    get schema(): Maybe<SchemaObject<SchemaObject.UserDefinedType>>;
+    private get _schema();
     private get typeSchemaVariable();
     createInitializer({ variables, }: Parameters<ObjectType_AbstractProperty["createInitializer"]>[0]): Maybe<Code>;
     equalsExpression({ variables, }: Parameters<ObjectType_AbstractProperty["equalsExpression"]>[0]): Maybe<Code>;

package/dist/generators/ts/_ObjectType/ObjectType_ShaclProperty.js

@@ -6,6 +6,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
+import { SchemaObject } from "../SchemaObject.js";
 import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
 import { tsComment } from "../tsComment.js";
 import { ObjectType_AbstractProperty } from "./ObjectType_AbstractProperty.js";
@@ -106,33 +107,50 @@ export class ObjectType_ShaclProperty extends ObjectType_AbstractProperty {
         });
     }
     get schema() {
-        const initializers = [code `kind: ${literalOf(this.kind)}`];
+        return Maybe.of(this._schema);
+    }
+    get _schema() {
+        // if (
+        //   this.objectType.name.extract() === "DirectRecursiveStruct" ||
+        //   this.objectType.name.extract() === "IndirectRecursiveStruct"
+        // ) {
+        //   console.log("test");
+        // }
+        const properties = {
+            kind: code `kind: ${literalOf(this.kind)}`,
+        };
+        const typeMembers = {
+            kind: code `readonly kind: ${literalOf(this.kind)}`,
+        };
         if (this.configuration.features.has("Object.fromRdf") ||
             this.configuration.features.has("Object.toRdf")) {
-            initializers.push(code `path: ${this.propertyPathToCode(this.path)}`);
+            properties["path"] = code `path: ${this.propertyPathToCode(this.path)}`;
+            typeMembers["path"] =
+                code `readonly path: ${this.reusables.snippets.PropertyPath}`;
         }
         // Use a getter if the type is recursive or the type is an object type, which may have forward references in the file
         if (this.recursive || this.type.referencesNamedType) {
-            initializers.push(code `get type() { return ${this.type.schema}; }`);
+            properties["type"] = () => code `get type() { return ${this.type.schema.expression}; }`;
+            typeMembers["type"] = () => code `readonly type: ${this.type.schema.type.expression}`;
         }
         else {
-            initializers.push(code `type: ${this.type.schema}`);
-        }
-        return Maybe.of(code `{ ${joinCode(initializers, { on: ", " })} }`);
-    }
-    get schemaType() {
-        const initializers = [code `readonly kind: ${literalOf(this.kind)}`];
-        if (this.configuration.features.has("Object.fromRdf") ||
-            this.configuration.features.has("Object.toRdf")) {
-            initializers.push(code `readonly path: ${this.reusables.snippets.PropertyPath}`);
+            properties["type"] = code `type: ${this.type.schema.expression}`;
+            typeMembers["type"] =
+                code `readonly type: ${this.type.schema.type.expression}`;
         }
-        initializers.push(code `readonly type: ${this.type.schemaType}`);
-        return Maybe.of(code `{ ${joinCode(initializers, { on: ", " })} }`);
+        return new SchemaObject({
+            properties,
+            type: new SchemaObject.UserDefinedType({
+                members: typeMembers,
+                name: Maybe.empty(),
+            }),
+            variable: this.schemaVariable,
+        });
     }
     get typeSchemaVariable() {
-        return this.objectType.name
-            .map((name) => code `${name}.schema.properties.${this.name}.type`)
-            .orDefaultLazy(() => this.type.schema);
+        return this.schemaVariable
+            .map((schemaVariable) => code `${schemaVariable}.type`)
+            .orDefaultLazy(() => this.type.schema.expression);
     }
     createInitializer({ variables, }) {
         const parameterVariable = code `${variables.parameters}.${this.name}`;
@@ -169,11 +187,11 @@ export class ObjectType_ShaclProperty extends ObjectType_AbstractProperty {
     }
     fromRdfResourceValuesInitializer({ variables, }) {
         return Maybe.of(code `${this.name}:
-        ${this.reusables.snippets.shaclPropertyFromRdf}<${this.type.expression}, ${this.type.schemaType}>({
+        ${this.reusables.snippets.shaclPropertyFromRdf}<${this.type.expression}, ${this.type.schema.type.expression}>({
           ...${variables.options},
           focusResource: ${variables.focusResource},
           ignoreRdfType: true,
-          propertySchema: ${this.schemaVariable},
+          propertySchema: ${this._schema.expression},
           typeFromRdfResourceValues: ${this.type.fromRdfResourceValuesFunction.unannotatedUsage} 
         })`);
     }
@@ -190,7 +208,7 @@ export class ObjectType_ShaclProperty extends ObjectType_AbstractProperty {
             focusIdentifier: variables.focusIdentifier,
             ignoreRdfType: true,
             propertyName: this.name,
-            propertySchema: this.schemaVariable,
+            propertySchema: this._schema.expression,
             typeSparqlConstructTriples: this.type.valueSparqlConstructTriplesFunction.unannotatedUsage,
             variablePrefix: variables.variablePrefix,
         }})`);
@@ -205,7 +223,7 @@ export class ObjectType_ShaclProperty extends ObjectType_AbstractProperty {
                 ignoreRdfType: true,
                 preferredLanguages: variables.preferredLanguages,
                 propertyName: this.name,
-                propertySchema: this.schemaVariable,
+                propertySchema: this._schema.expression,
                 typeSparqlWherePatterns: this.type.valueSparqlWherePatternsFunction.unannotatedUsage,
                 variablePrefix: variables.variablePrefix,
             }})`,
@@ -231,7 +249,7 @@ export class ObjectType_ShaclProperty extends ObjectType_AbstractProperty {
                 return [];
         }
         const propertyPath = this.objectType.name
-            .map(() => code `${this.schemaVariable}.path`)
+            .map(() => code `${this._schema.expression}.path`)
             .orDefault(this.propertyPathToCode(this.path));
         const { object: objectVariable, ...otherVariables } = variables;
         return [
@@ -281,6 +299,12 @@ __decorate([
 __decorate([
     Memoize()
 ], ObjectType_ShaclProperty.prototype, "jsonObjectMember", null);
+__decorate([
+    Memoize()
+], ObjectType_ShaclProperty.prototype, "schema", null);
+__decorate([
+    Memoize()
+], ObjectType_ShaclProperty.prototype, "_schema", null);
 __decorate([
     Memoize()
 ], ObjectType_ShaclProperty.prototype, "typeSchemaVariable", null);

package/dist/generators/ts/_ObjectType/ObjectType_fromRdfResourceValuesFunction.js

@@ -3,6 +3,6 @@ export function ObjectType_fromRdfResourceValuesFunctionExpression() {
     return code `(values, options) => values.chainMap(value => value.toResource().chain(resource => ${this.fromRdfResourceFunction.annotatedUsage}(resource, options)))`;
 }
 export function ObjectType_fromRdfResourceValuesFunctionType() {
-    return code `${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.discriminatedType.map((discriminatedType) => discriminatedType.expression).orDefault(this.expression)}, ${this.schemaType}>`;
+    return code `${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.discriminatedType.map((discriminatedType) => discriminatedType.expression).orDefault(this.expression)}, ${this.schema.type.expression}>`;
 }
 //# sourceMappingURL=ObjectType_fromRdfResourceValuesFunction.js.map

package/dist/generators/ts/_ObjectType/ObjectType_jsonObjectType.d.ts

@@ -0,0 +1,4 @@
+import type { AbstractUserDefinedType } from "../AbstractUserDefinedType.js";
+import type { ObjectType } from "../ObjectType.js";
+export declare function ObjectType_jsonObjectType(this: ObjectType): AbstractUserDefinedType["jsonObjectType"];
+//# sourceMappingURL=ObjectType_jsonObjectType.d.ts.map

package/dist/generators/ts/_ObjectType/ObjectType_jsonObjectType.js

@@ -0,0 +1,26 @@
+import { InlineCallable } from "../InlineCallable.js";
+import { code, literalOf } from "../ts-poet-wrapper.js";
+export function ObjectType_jsonObjectType() {
+    // If the JSON object type is { "@id": string }, allow a shorthand of string => that type.
+    let shorthand;
+    this.identifierProperty.ifJust((identifierProperty) => {
+        const fromJsonObjectInitializerParameters = {
+            variables: { context: code ``, jsonObject: code ``, options: code `` },
+        };
+        if (this.properties.some((property) => !Object.is(property, identifierProperty) &&
+            property
+                .fromJsonObjectInitializer(fromJsonObjectInitializerParameters)
+                .isJust())) {
+            return;
+        }
+        shorthand = {
+            transformer: new InlineCallable(code `(id) => ({ ${literalOf(identifierProperty.jsonObjectMember.unsafeCoerce().name)}: id })`),
+            type: identifierProperty.type.jsonValueType,
+        };
+    });
+    return this.jsonTypeFactory.createJsonObjectType(this.properties.flatMap((property) => property.jsonObjectMember.toList()), {
+        name: this.name.map((name) => [name, "Json"]).extract(),
+        shorthand,
+    });
+}
+//# sourceMappingURL=ObjectType_jsonObjectType.js.map

package/dist/generators/ts/_snippets/snippets_LazySchema.d.ts

@@ -0,0 +1,3 @@
+import type { SnippetFactory } from "../SnippetFactory.js";
+export declare const snippets_LazySchema: SnippetFactory;
+//# sourceMappingURL=snippets_LazySchema.d.ts.map

package/dist/generators/ts/_snippets/snippets_LazySchema.js

@@ -0,0 +1,7 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_LazySchema = ({ syntheticNamePrefix }) => conditionalOutput(`${syntheticNamePrefix}LazySchema`, code `\
+interface ${syntheticNamePrefix}LazySchema<PartialSchemaT>{
+  readonly kind: "Lazy" | "LazyOption" | "LazySet";
+  readonly partialType: PartialSchemaT;
+}`);
+//# sourceMappingURL=snippets_LazySchema.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "dependencies": {
-    "@shaclmate/shacl-ast": "4.0.98",
+    "@shaclmate/shacl-ast": "4.0.100",
     "@rdfjs/types": "~2.0.1",
     "@rdfx/collection": "0.0.59",
     "@rdfx/curie": "0.0.59",
@@ -136,6 +136,8 @@
     "dist/generators/index.js",
     "dist/generators/transformAstToLabeledPropertyGraph.d.ts",
     "dist/generators/transformAstToLabeledPropertyGraph.js",
+    "dist/generators/ts/AbstractBuiltinType.d.ts",
+    "dist/generators/ts/AbstractBuiltinType.js",
     "dist/generators/ts/AbstractCallable.d.ts",
     "dist/generators/ts/AbstractCallable.js",
     "dist/generators/ts/AbstractCollectionType.d.ts",
@@ -164,14 +166,14 @@
     "dist/generators/ts/AbstractObjectSetType.js",
     "dist/generators/ts/AbstractPrimitiveType.d.ts",
     "dist/generators/ts/AbstractPrimitiveType.js",
-    "dist/generators/ts/AbstractStructuredType.d.ts",
-    "dist/generators/ts/AbstractStructuredType.js",
     "dist/generators/ts/AbstractTermType.d.ts",
     "dist/generators/ts/AbstractTermType.js",
     "dist/generators/ts/AbstractType.d.ts",
     "dist/generators/ts/AbstractType.js",
     "dist/generators/ts/AbstractTypedLiteralType.d.ts",
     "dist/generators/ts/AbstractTypedLiteralType.js",
+    "dist/generators/ts/AbstractUserDefinedType.d.ts",
+    "dist/generators/ts/AbstractUserDefinedType.js",
     "dist/generators/ts/BigDecimalType.d.ts",
     "dist/generators/ts/BigDecimalType.js",
     "dist/generators/ts/BigIntType.d.ts",
@@ -180,6 +182,8 @@
     "dist/generators/ts/BlankNodeType.js",
     "dist/generators/ts/BooleanType.d.ts",
     "dist/generators/ts/BooleanType.js",
+    "dist/generators/ts/BuiltinCallable.d.ts",
+    "dist/generators/ts/BuiltinCallable.js",
     "dist/generators/ts/Callable.d.ts",
     "dist/generators/ts/Callable.js",
     "dist/generators/ts/CodeThunk.d.ts",
@@ -234,10 +238,10 @@
     "dist/generators/ts/OptionType.js",
     "dist/generators/ts/RdfjsDatasetObjectSetType.d.ts",
     "dist/generators/ts/RdfjsDatasetObjectSetType.js",
-    "dist/generators/ts/ReferenceCallable.d.ts",
-    "dist/generators/ts/ReferenceCallable.js",
     "dist/generators/ts/Reusables.d.ts",
     "dist/generators/ts/Reusables.js",
+    "dist/generators/ts/SchemaObject.d.ts",
+    "dist/generators/ts/SchemaObject.js",
     "dist/generators/ts/Service.d.ts",
     "dist/generators/ts/Service.js",
     "dist/generators/ts/SetType.d.ts",
@@ -288,8 +292,6 @@
     "dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_inferDiscriminant.js",
     "dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_inlineExpression.d.ts",
     "dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_inlineExpression.js",
-    "dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_schemaTypeExpression.d.ts",
-    "dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_schemaTypeExpression.js",
     "dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_toJsonObjectFunction.d.ts",
     "dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_toJsonObjectFunction.js",
     "dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_toLoggableFunction.d.ts",
@@ -412,12 +414,10 @@
     "dist/generators/ts/_ObjectType/ObjectType_hashFunction.js",
     "dist/generators/ts/_ObjectType/ObjectType_identifierTypeDeclarations.d.ts",
     "dist/generators/ts/_ObjectType/ObjectType_identifierTypeDeclarations.js",
+    "dist/generators/ts/_ObjectType/ObjectType_jsonObjectType.d.ts",
+    "dist/generators/ts/_ObjectType/ObjectType_jsonObjectType.js",
     "dist/generators/ts/_ObjectType/ObjectType_objectSetMethodNames.d.ts",
     "dist/generators/ts/_ObjectType/ObjectType_objectSetMethodNames.js",
-    "dist/generators/ts/_ObjectType/ObjectType_schemaExpression.d.ts",
-    "dist/generators/ts/_ObjectType/ObjectType_schemaExpression.js",
-    "dist/generators/ts/_ObjectType/ObjectType_schemaTypeExpression.d.ts",
-    "dist/generators/ts/_ObjectType/ObjectType_schemaTypeExpression.js",
     "dist/generators/ts/_ObjectType/ObjectType_sparqlConstructQueryFunction.d.ts",
     "dist/generators/ts/_ObjectType/ObjectType_sparqlConstructQueryFunction.js",
     "dist/generators/ts/_ObjectType/ObjectType_sparqlConstructQueryStringFunction.d.ts",
@@ -500,6 +500,8 @@
     "dist/generators/ts/_snippets/snippets_Lazy.js",
     "dist/generators/ts/_snippets/snippets_LazyOption.d.ts",
     "dist/generators/ts/_snippets/snippets_LazyOption.js",
+    "dist/generators/ts/_snippets/snippets_LazySchema.d.ts",
+    "dist/generators/ts/_snippets/snippets_LazySchema.js",
     "dist/generators/ts/_snippets/snippets_LazySet.d.ts",
     "dist/generators/ts/_snippets/snippets_LazySet.js",
     "dist/generators/ts/_snippets/snippets_LiteralFilter.d.ts",
@@ -976,5 +978,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "4.0.98"
+  "version": "4.0.100"
 }

package/dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_schemaTypeExpression.d.ts

@@ -1,5 +0,0 @@
-import type { AbstractDiscriminatedUnionType } from "../AbstractDiscriminatedUnionType.js";
-import type { Type } from "../Type.js";
-import { type Code } from "../ts-poet-wrapper.js";
-export declare function AbstractDiscriminatedUnionType_schemaTypeExpression<MemberTypeT extends Type>(this: AbstractDiscriminatedUnionType<MemberTypeT>): Code;
-//# sourceMappingURL=AbstractDiscriminatedUnionType_schemaTypeExpression.d.ts.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_schemaTypeExpression.js

@@ -1,11 +0,0 @@
-import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
-export function AbstractDiscriminatedUnionType_schemaTypeExpression() {
-    return code `${{
-        kind: this.kind,
-        members: code `{ ${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `readonly ${literalOf(primaryDiscriminantValue)}: ${{
-            discriminantValues: code `readonly (number | string)[]`,
-            type: type.schemaType,
-        }}`), { on: ";" })} }`,
-    }}`;
-}
-//# sourceMappingURL=AbstractDiscriminatedUnionType_schemaTypeExpression.js.map

package/dist/generators/ts/_ObjectType/ObjectType_schemaExpression.d.ts

@@ -1,4 +0,0 @@
-import type { ObjectType } from "../ObjectType.js";
-import { type Code } from "../ts-poet-wrapper.js";
-export declare function ObjectType_schemaExpression(this: ObjectType): Code;
-//# sourceMappingURL=ObjectType_schemaExpression.d.ts.map

package/dist/generators/ts/_ObjectType/ObjectType_schemaExpression.js

@@ -1,15 +0,0 @@
-import { invariant } from "ts-invariant";
-import { code } from "../ts-poet-wrapper.js";
-export function ObjectType_schemaExpression() {
-    const schema = {};
-    const properties = {};
-    for (const property of this.properties) {
-        property.schema.ifJust((propertySchema) => {
-            properties[property.name] = propertySchema;
-        });
-    }
-    invariant(Object.keys(properties).length > 0);
-    schema["properties"] = properties;
-    return code `${schema} as const`;
-}
-//# sourceMappingURL=ObjectType_schemaExpression.js.map

package/dist/generators/ts/_ObjectType/ObjectType_schemaTypeExpression.d.ts

@@ -1,4 +0,0 @@
-import type { ObjectType } from "../ObjectType.js";
-import { type Code } from "../ts-poet-wrapper.js";
-export declare function ObjectType_schemaTypeExpression(this: ObjectType): Code;
-//# sourceMappingURL=ObjectType_schemaTypeExpression.d.ts.map

package/dist/generators/ts/_ObjectType/ObjectType_schemaTypeExpression.js

@@ -1,15 +0,0 @@
-import { invariant } from "ts-invariant";
-import { code } from "../ts-poet-wrapper.js";
-export function ObjectType_schemaTypeExpression() {
-    const schemaType = {};
-    const properties = {};
-    for (const property of this.properties) {
-        property.schemaType.ifJust((propertySchemaType) => {
-            properties[property.name] = propertySchemaType;
-        });
-    }
-    invariant(Object.keys(properties).length > 0);
-    schemaType["properties"] = properties;
-    return code `${schemaType}`;
-}
-//# sourceMappingURL=ObjectType_schemaTypeExpression.js.map