@shaclmate/compiler 4.0.94 → 4.0.96

package/dist/generators/ts/ListType.js

@@ -8,6 +8,8 @@ import { rdf } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractCollectionType } from "./AbstractCollectionType.js";
+import { InlineCallable } from "./InlineCallable.js";
+import { ReferenceCallable } from "./ReferenceCallable.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 export class ListType extends AbstractCollectionType {
     identifierNodeKind;
@@ -21,6 +23,9 @@ export class ListType extends AbstractCollectionType {
         this.identifierNodeKind = identifierNodeKind;
         this.toRdfTypes = toRdfTypes;
     }
+    get jsonValueType() {
+        return this.jsonTypeFactory.createJsonArrayType(this.itemType.jsonValueType);
+    }
     get conversionFunction() {
         const itemConversionFunction = this.itemType.conversionFunction.orDefault(this.itemConversionFunctionDefault);
         return Maybe.of({
@@ -33,32 +38,34 @@ export class ListType extends AbstractCollectionType {
             ],
         });
     }
+    get jsonObjectType() {
+        return this.jsonTypeFactory.createJsonObjectType({
+            "@list": { type: this.jsonValueType },
+        });
+    }
+    get fromJsonValueFunction() {
+        return new ReferenceCallable(code `${this.reusables.snippets.arrayFromJsonArray}(${this.itemType.fromJsonValueFunction.annotatedUsage})`);
+    }
+    get fromJsonObjectFunction() {
+        return new ReferenceCallable(code `${this.reusables.snippets.listFromJsonObject}(${this.itemType.fromJsonValueFunction.annotatedUsage})`);
+    }
     get fromRdfResourceValuesFunction() {
-        return code `${this._mutable ? this.reusables.snippets.mutableListFromRdfResourceValues : this.reusables.snippets.listFromRdfResourceValues}<${this.itemType.expression}, ${this.itemType.schemaType}>(${this.itemType.fromRdfResourceValuesFunction})`;
+        return new InlineCallable(code `${this._mutable ? this.reusables.snippets.mutableListFromRdfResourceValues : this.reusables.snippets.listFromRdfResourceValues}<${this.itemType.expression}, ${this.itemType.schemaType}>(${this.itemType.fromRdfResourceValuesFunction.unannotatedUsage})`);
+    }
+    get toJsonValueFunction() {
+        return new ReferenceCallable(code `${this.reusables.snippets.arrayToJsonArray}(${this.itemType.toJsonValueFunction.annotatedUsage})`);
+    }
+    get toJsonObjectFunction() {
+        return new InlineCallable(code `${this.reusables.snippets.listToJsonObject}(${this.itemType.toJsonValueFunction.annotatedUsage})`);
     }
     get toRdfResourceValueTypes() {
         return new Set(["BlankNode", "NamedNode"]); // List or rdf:nil
     }
     get valueSparqlConstructTriplesFunction() {
-        return code `${this.reusables.snippets.listSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlConstructTriplesFunction})`;
+        return new InlineCallable(code `${this.reusables.snippets.listSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlConstructTriplesFunction.unannotatedUsage})`);
     }
     get valueSparqlWherePatternsFunction() {
-        return code `${this.reusables.snippets.listSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction})`;
-    }
-    fromJsonExpression({ variables, }) {
-        return code `${this.reusables.imports.Either}.sequence<Error, ${this.itemType.expression}>(${variables.value}.map(item => (${this.itemType.fromJsonExpression({
-            variables: { value: code `item` },
-        })})))`;
-    }
-    jsonSchema(parameters) {
-        let schema = code `${this.itemType.jsonSchema(parameters)}.array()`;
-        if (!this._mutable) {
-            schema = code `${schema}.readonly()`;
-        }
-        return schema;
-    }
-    jsonType() {
-        return new AbstractCollectionType.JsonType(code `${!this.mutable ? "readonly " : ""}(${this.itemType.jsonType().expression})[]`);
+        return new InlineCallable(code `${this.reusables.snippets.listSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction.unannotatedUsage})`);
     }
     toRdfResourceValuesExpression({ variables, }) {
         let mintListIdentifierFunction;
@@ -108,12 +115,30 @@ export class ListType extends AbstractCollectionType {
         return code `\`[\${${variables.value}.map(item => (${this.itemType.toStringExpression({ variables: { value: code `item` } })}))}]\``;
     }
 }
+__decorate([
+    Memoize()
+], ListType.prototype, "jsonValueType", null);
 __decorate([
     Memoize()
 ], ListType.prototype, "conversionFunction", null);
+__decorate([
+    Memoize()
+], ListType.prototype, "jsonObjectType", null);
+__decorate([
+    Memoize()
+], ListType.prototype, "fromJsonValueFunction", null);
+__decorate([
+    Memoize()
+], ListType.prototype, "fromJsonObjectFunction", null);
 __decorate([
     Memoize()
 ], ListType.prototype, "fromRdfResourceValuesFunction", null);
+__decorate([
+    Memoize()
+], ListType.prototype, "toJsonValueFunction", null);
+__decorate([
+    Memoize()
+], ListType.prototype, "toJsonObjectFunction", null);
 __decorate([
     Memoize()
 ], ListType.prototype, "toRdfResourceValueTypes", null);
@@ -123,9 +148,6 @@ __decorate([
 __decorate([
     Memoize()
 ], ListType.prototype, "valueSparqlWherePatternsFunction", null);
-__decorate([
-    Memoize()
-], ListType.prototype, "jsonType", null);
 (function (ListType) {
     function isItemType(type) {
         switch (type.kind) {
@@ -138,12 +160,13 @@ __decorate([
             case "DiscriminatedUnion":
             case "Float":
             case "Identifier":
-            case "Iri":
             case "Int":
+            case "Iri":
             case "LangString":
             case "List":
             case "Literal":
             case "ObjectDiscriminatedUnion":
+            case "ObjectIntersection":
             case "Object":
             case "String":
             case "Term":

package/dist/generators/ts/LiteralType.d.ts

@@ -1,31 +1,35 @@
 import type { Literal } from "@rdfjs/types";
 import { Maybe } from "purify-ts";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
+import { ReferenceCallable } from "./ReferenceCallable.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class LiteralType extends AbstractLiteralType {
     private readonly languageIn;
     protected readonly inlineExpression: Code;
     readonly conversionFunction: Maybe<AbstractLiteralType.ConversionFunction>;
-    readonly filterFunction: Code;
+    readonly filterFunction: ReferenceCallable;
     readonly filterType: Code;
-    readonly fromRdfResourceValuesFunction: Code;
+    readonly fromJsonObjectFunction: ReferenceCallable;
+    readonly fromJsonValueFunction: ReferenceCallable;
+    readonly fromRdfResourceValuesFunction: ReferenceCallable;
     readonly jsTypes: readonly [{
         readonly instanceof: "Object";
         readonly typeof: "object";
     }];
+    readonly jsonValueType: AbstractLiteralType["jsonValueType"];
     readonly kind = "Literal";
     readonly schemaType: Code;
-    readonly valueSparqlWherePatternsFunction: Code;
+    readonly toJsonObjectFunction: ReferenceCallable;
+    readonly toJsonValueFunction: ReferenceCallable;
+    readonly valueSparqlWherePatternsFunction: ReferenceCallable;
     constructor({ languageIn, ...superParameters }: {
         languageIn: readonly string[];
     } & ConstructorParameters<typeof AbstractLiteralType>[0]);
+    get discriminatedType(): Maybe<AbstractLiteralType.DiscriminatedType>;
     get graphqlType(): AbstractLiteralType.GraphqlType;
     protected get schemaInitializers(): readonly Code[];
-    fromJsonExpression({ variables, }: Parameters<AbstractLiteralType["fromJsonExpression"]>[0]): Code;
     graphqlResolveExpression(_parameters: Parameters<AbstractLiteralType["graphqlResolveExpression"]>[0]): Code;
-    jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractLiteralType["jsonSchema"]>[0]): Code;
-    jsonType(parameters?: Parameters<AbstractLiteralType["jsonType"]>[0]): AbstractLiteralType.JsonType;
+    toLoggableExpression({ variables, }: Parameters<AbstractLiteralType["toLoggableExpression"]>[0]): Code;
     valueExpression(literal: Literal): Code;
-    toJsonExpression({ includeDiscriminantProperty, variables, }: Parameters<AbstractLiteralType["toJsonExpression"]>[0]): Code;
 }
 //# sourceMappingURL=LiteralType.d.ts.map

package/dist/generators/ts/LiteralType.js

@@ -1,6 +1,13 @@
-import { xsd } from "@tpluscode/rdf-ns-builders";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
 import { Maybe } from "purify-ts";
+import { Memoize } from "typescript-memoize";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
+import { ReferenceCallable } from "./ReferenceCallable.js";
 import { arrayOf, code } from "./ts-poet-wrapper.js";
 export class LiteralType extends AbstractLiteralType {
     languageIn;
@@ -22,19 +29,34 @@ export class LiteralType extends AbstractLiteralType {
             },
         ],
     });
-    filterFunction = code `${this.reusables.snippets.filterLiteral}`;
+    filterFunction = new ReferenceCallable(this.reusables.snippets.filterLiteral);
     filterType = code `${this.reusables.snippets.LiteralFilter}`;
-    fromRdfResourceValuesFunction = code `${this.reusables.snippets.literalFromRdfResourceValues}`;
+    fromJsonObjectFunction = new ReferenceCallable(this.reusables.snippets.literalFromJsonObject);
+    fromJsonValueFunction = this.fromJsonObjectFunction;
+    fromRdfResourceValuesFunction = new ReferenceCallable(this.reusables.snippets.literalFromRdfResourceValues);
     jsTypes = [
         { instanceof: "Object", typeof: "object" },
     ];
+    jsonValueType = this.jsonObjectType;
     kind = "Literal";
     schemaType = code `${this.reusables.snippets.LiteralSchema}`;
-    valueSparqlWherePatternsFunction = code `${this.reusables.snippets.literalSparqlWherePatterns}`;
+    toJsonObjectFunction = new ReferenceCallable(this.reusables.snippets.literalToJsonObject);
+    toJsonValueFunction = this.toJsonObjectFunction;
+    valueSparqlWherePatternsFunction = new ReferenceCallable(this.reusables.snippets.literalSparqlWherePatterns);
     constructor({ languageIn, ...superParameters }) {
         super(superParameters);
         this.languageIn = languageIn;
     }
+    get discriminatedType() {
+        return Maybe.of({
+            discriminantProperty: {
+                jsonName: "termType",
+                name: "termType",
+                values: [...this.termTypes],
+            },
+            expression: this.expression,
+        });
+    }
     get graphqlType() {
         throw new Error("not implemented");
     }
@@ -45,29 +67,17 @@ export class LiteralType extends AbstractLiteralType {
         }
         return initializers;
     }
-    fromJsonExpression({ variables, }) {
-        return code `${this.reusables.imports.Either}.of<Error, ${this.expression}>(${this.reusables.imports.dataFactory}.literal(${variables.value}["@value"], ${variables.value}["@language"] !== undefined ? ${variables.value}["@language"] : (${variables.value}["@type"] !== undefined ? ${this.reusables.imports.dataFactory}.namedNode(${variables.value}["@type"]!) : undefined)))`;
-    }
     graphqlResolveExpression(_parameters) {
         throw new Error("not implemented");
     }
-    jsonSchema({ includeDiscriminantProperty, }) {
-        const discriminantProperty = includeDiscriminantProperty
-            ? code `, termType: ${this.reusables.imports.z}.literal("Literal")`
-            : "";
-        return code `${this.reusables.imports.z}.object({ "@language": ${this.reusables.imports.z}.string().optional()${discriminantProperty}, "@type": ${this.reusables.imports.z}.string().optional(), "@value": ${this.reusables.imports.z}.string() })`;
-    }
-    jsonType(parameters) {
-        const discriminantProperty = parameters?.includeDiscriminantProperty
-            ? `, readonly termType: "Literal"`
-            : "";
-        return new AbstractLiteralType.JsonType(code `{ readonly "@language"?: string${discriminantProperty}, readonly "@type"?: string, readonly "@value": string }`);
+    toLoggableExpression({ variables, }) {
+        return code `{ datatype: ${variables.value}.datatype.value, language: ${variables.value}.language.length > 0 ? ${variables.value}.language : undefined, value: ${variables.value}.value }`;
     }
     valueExpression(literal) {
         return this.rdfjsTermExpression(literal);
     }
-    toJsonExpression({ includeDiscriminantProperty, variables, }) {
-        return code `{ "@language": ${variables.value}.language.length > 0 ? ${variables.value}.language : undefined${includeDiscriminantProperty ? `, "termType": "Literal" as const` : ""}, "@type": ${variables.value}.datatype.value !== "${xsd.string.value}" ? ${variables.value}.datatype.value : undefined, "@value": ${variables.value}.value }`;
-    }
 }
+__decorate([
+    Memoize()
+], LiteralType.prototype, "discriminatedType", null);
 //# sourceMappingURL=LiteralType.js.map

package/dist/generators/ts/ObjectDiscriminatedUnionType.d.ts

@@ -1,12 +1,29 @@
-import { Maybe } from "purify-ts";
+import type { Maybe } from "purify-ts";
+import { ObjectDiscriminatedUnionType_schemaExpression } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_schemaExpression.js";
 import { AbstractDiscriminatedUnionType } from "./AbstractDiscriminatedUnionType.js";
+import type { BlankNodeType } from "./BlankNodeType.js";
+import type { Callable } from "./Callable.js";
+import type { IdentifierType } from "./IdentifierType.js";
+import type { IriType } from "./IriType.js";
 import type { ObjectType } from "./ObjectType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class ObjectDiscriminatedUnionType extends AbstractDiscriminatedUnionType<ObjectType> {
+    protected schemaExpression: typeof ObjectDiscriminatedUnionType_schemaExpression;
+    readonly identifierType: BlankNodeType | IdentifierType | IriType;
     readonly kind = "ObjectDiscriminatedUnion";
+    constructor({ identifierType, ...superParameters }: {
+        identifierType: BlankNodeType | IdentifierType | IriType;
+    } & ConstructorParameters<typeof AbstractDiscriminatedUnionType<ObjectType>>[0]);
+    get focusSparqlConstructTriplesFunction(): Callable;
+    get focusSparqlWherePatternsFunction(): Callable;
+    get fromRdfResourceFunction(): Callable;
     get identifierTypeAlias(): Code;
     get objectSetMethodNames(): ObjectType.ObjectSetMethodNames;
-    get typeGuardFunction(): Maybe<Code>;
+    get sparqlConstructQueryFunction(): Callable;
+    get sparqlConstructQueryStringFunction(): Callable;
+    get toRdfResourceFunction(): Callable;
+    get typeGuardFunction(): Maybe<Callable>;
+    protected get inlineExpression(): Code;
     protected staticModuleDeclarations(name: string): Record<string, Code>;
 }
 //# sourceMappingURL=ObjectDiscriminatedUnionType.d.ts.map

package/dist/generators/ts/ObjectDiscriminatedUnionType.js

@@ -4,24 +4,39 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
-import { ObjectDiscriminatedUnionType_focusSparqlConstructTriplesFunctionDeclaration } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_focusSparqlConstructTriplesFunctionDeclaration.js";
-import { ObjectDiscriminatedUnionType_focusSparqlWherePatternsFunctionDeclaration } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_focusSparqlWherePatternsFunctionDeclaration.js";
-import { ObjectDiscriminatedUnionType_fromRdfResourceFunctionDeclaration } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_fromRdfResourceFunctionDeclaration.js";
-import { ObjectDiscriminatedUnionType_graphqlTypeVariableStatement } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_graphqlTypeVariableStatement.js";
-import { ObjectDiscriminatedUnionType_identifierTypeDeclarations } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_identifierTypeDeclarations.js";
-import { ObjectDiscriminatedUnionType_schemaVariableStatement } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_schemaVariableStatement.js";
-import { ObjectDiscriminatedUnionType_toRdfResourceFunctionDeclaration } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_toRdfResourceFunctionDeclaration.js";
-import { ObjectDiscriminatedUnionType_typeGuardFunctionDeclaration } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_typeGuardFunctionDeclaration.js";
+import { ObjectDiscriminatedUnionType_focusSparqlConstructTriplesFunction } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_focusSparqlConstructTriplesFunction.js";
+import { ObjectDiscriminatedUnionType_focusSparqlWherePatternsFunction } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_focusSparqlWherePatternsFunction.js";
+import { ObjectDiscriminatedUnionType_fromRdfResourceFunction } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_fromRdfResourceFunction.js";
+import { ObjectDiscriminatedUnionType_graphqlTypeExpression } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_graphqlTypeExpression.js";
+import { ObjectDiscriminatedUnionType_schemaExpression } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_schemaExpression.js";
+import { ObjectDiscriminatedUnionType_toRdfResourceFunction } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_toRdfResourceFunction.js";
+import { ObjectDiscriminatedUnionType_typeGuardFunction } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_typeGuardFunction.js";
+import { ObjectType_identifierTypeDeclarations } from "./_ObjectType/ObjectType_identifierTypeDeclarations.js";
 import { ObjectType_objectSetMethodNames } from "./_ObjectType/ObjectType_objectSetMethodNames.js";
-import { ObjectType_sparqlConstructQueryFunctionDeclaration } from "./_ObjectType/ObjectType_sparqlConstructQueryFunctionDeclaration.js";
-import { ObjectType_sparqlConstructQueryStringFunctionDeclaration } from "./_ObjectType/ObjectType_sparqlConstructQueryStringFunctionDeclaration.js";
+import { ObjectType_sparqlConstructQueryFunction } from "./_ObjectType/ObjectType_sparqlConstructQueryFunction.js";
+import { ObjectType_sparqlConstructQueryStringFunction } from "./_ObjectType/ObjectType_sparqlConstructQueryStringFunction.js";
 import { AbstractDiscriminatedUnionType } from "./AbstractDiscriminatedUnionType.js";
-import { singleEntryRecord } from "./singleEntryRecord.js";
-import { code } from "./ts-poet-wrapper.js";
+import { DeclaredCallable } from "./DeclaredCallable.js";
+import { code, joinCode } from "./ts-poet-wrapper.js";
 export class ObjectDiscriminatedUnionType extends AbstractDiscriminatedUnionType {
+    schemaExpression = ObjectDiscriminatedUnionType_schemaExpression;
+    identifierType;
     kind = "ObjectDiscriminatedUnion";
+    constructor({ identifierType, ...superParameters }) {
+        super(superParameters);
+        this.identifierType = identifierType;
+    }
+    get focusSparqlConstructTriplesFunction() {
+        return ObjectDiscriminatedUnionType_focusSparqlConstructTriplesFunction.call(this);
+    }
+    get focusSparqlWherePatternsFunction() {
+        return ObjectDiscriminatedUnionType_focusSparqlWherePatternsFunction.call(this);
+    }
+    get fromRdfResourceFunction() {
+        return ObjectDiscriminatedUnionType_fromRdfResourceFunction.call(this);
+    }
     get identifierTypeAlias() {
         return this.name.map((name) => code `${name}.Identifier`).unsafeCoerce();
     }
@@ -33,49 +48,98 @@ export class ObjectDiscriminatedUnionType extends AbstractDiscriminatedUnionType
         }))
             .unsafeCoerce();
     }
+    get sparqlConstructQueryFunction() {
+        return ObjectType_sparqlConstructQueryFunction.call({
+            configuration: this.configuration,
+            filterType: this.filterType,
+            _function: this._function.bind(this),
+            focusSparqlConstructTriplesFunction: this.focusSparqlConstructTriplesFunction,
+            focusSparqlWherePatternsFunction: this.focusSparqlWherePatternsFunction,
+            name: this.name,
+            reusables: this.reusables,
+        });
+    }
+    get sparqlConstructQueryStringFunction() {
+        return ObjectType_sparqlConstructQueryStringFunction.call({
+            configuration: this.configuration,
+            filterType: this.filterType,
+            _function: this._function.bind(this),
+            sparqlConstructQueryFunction: this.sparqlConstructQueryFunction,
+            reusables: this.reusables,
+        });
+    }
+    get toRdfResourceFunction() {
+        return ObjectDiscriminatedUnionType_toRdfResourceFunction.call(this);
+    }
     get typeGuardFunction() {
-        if (Object.keys(ObjectDiscriminatedUnionType_typeGuardFunctionDeclaration.call(this)).length === 0) {
-            return Maybe.empty();
+        return ObjectDiscriminatedUnionType_typeGuardFunction.call(this);
+    }
+    get inlineExpression() {
+        if (this.discriminant.kind === "Intrinsic") {
+            return code `(${joinCode(this.members.map(({ type }) => type.discriminatedType.unsafeCoerce().expression), { on: " | " })})`;
         }
-        return this.name.map((name) => code `${name}.is${name}`);
+        return super.inlineExpression;
     }
     staticModuleDeclarations(name) {
-        return {
+        const staticModuleDeclarations = {
             ...super.staticModuleDeclarations(name),
-            ...ObjectDiscriminatedUnionType_identifierTypeDeclarations.call(this),
-            ...ObjectDiscriminatedUnionType_focusSparqlConstructTriplesFunctionDeclaration.call(this),
-            ...ObjectDiscriminatedUnionType_focusSparqlWherePatternsFunctionDeclaration.call(this),
-            ...ObjectDiscriminatedUnionType_fromRdfResourceFunctionDeclaration.call(this),
-            ...ObjectDiscriminatedUnionType_graphqlTypeVariableStatement.call(this),
-            ...ObjectDiscriminatedUnionType_typeGuardFunctionDeclaration.call(this),
-            ...ObjectDiscriminatedUnionType_schemaVariableStatement.call(this),
-            ...(this.configuration.features.has("Object.SPARQL")
-                ? {
-                    ...singleEntryRecord("sparqlConstructQuery", ObjectType_sparqlConstructQueryFunctionDeclaration.call({
-                        name,
-                        configuration: this.configuration,
-                        filterType: this.filterType,
-                        reusables: this.reusables,
-                    })),
-                    ...singleEntryRecord("sparqlConstructQueryString", ObjectType_sparqlConstructQueryStringFunctionDeclaration.call({
-                        name,
-                        configuration: this.configuration,
-                        filterType: this.filterType,
-                        reusables: this.reusables,
-                    })),
-                }
-                : {}),
-            ...ObjectDiscriminatedUnionType_toRdfResourceFunctionDeclaration.call(this),
+            ...ObjectType_identifierTypeDeclarations.call(this),
         };
+        function addFunctionDeclaration(function_) {
+            invariant(function_ instanceof DeclaredCallable);
+            staticModuleDeclarations[function_.unqualifiedName] =
+                code `export ${function_.declaration}`;
+        }
+        if (this.configuration.features.has("Object.fromRdf")) {
+            addFunctionDeclaration(this.fromRdfResourceFunction);
+        }
+        if (this.configuration.features.has("GraphQL")) {
+            staticModuleDeclarations["GraphQL"] =
+                code `export const GraphQL = ${ObjectDiscriminatedUnionType_graphqlTypeExpression.call(this)};`;
+        }
+        if (this.configuration.features.has("Object.SPARQL")) {
+            addFunctionDeclaration(this.focusSparqlConstructTriplesFunction);
+            addFunctionDeclaration(this.focusSparqlWherePatternsFunction);
+            addFunctionDeclaration(this.sparqlConstructQueryFunction);
+            addFunctionDeclaration(this.sparqlConstructQueryStringFunction);
+        }
+        if (this.configuration.features.has("Object.toRdf")) {
+            addFunctionDeclaration(this.toRdfResourceFunction);
+        }
+        if (this.configuration.features.has("Object.type")) {
+            ObjectDiscriminatedUnionType_typeGuardFunction.call(this).ifJust(addFunctionDeclaration);
+        }
+        return staticModuleDeclarations;
     }
 }
+__decorate([
+    Memoize()
+], ObjectDiscriminatedUnionType.prototype, "focusSparqlConstructTriplesFunction", null);
+__decorate([
+    Memoize()
+], ObjectDiscriminatedUnionType.prototype, "focusSparqlWherePatternsFunction", null);
+__decorate([
+    Memoize()
+], ObjectDiscriminatedUnionType.prototype, "fromRdfResourceFunction", null);
 __decorate([
     Memoize()
 ], ObjectDiscriminatedUnionType.prototype, "identifierTypeAlias", null);
 __decorate([
     Memoize()
 ], ObjectDiscriminatedUnionType.prototype, "objectSetMethodNames", null);
+__decorate([
+    Memoize()
+], ObjectDiscriminatedUnionType.prototype, "sparqlConstructQueryFunction", null);
+__decorate([
+    Memoize()
+], ObjectDiscriminatedUnionType.prototype, "sparqlConstructQueryStringFunction", null);
+__decorate([
+    Memoize()
+], ObjectDiscriminatedUnionType.prototype, "toRdfResourceFunction", null);
 __decorate([
     Memoize()
 ], ObjectDiscriminatedUnionType.prototype, "typeGuardFunction", null);
+__decorate([
+    Memoize()
+], ObjectDiscriminatedUnionType.prototype, "inlineExpression", null);
 //# sourceMappingURL=ObjectDiscriminatedUnionType.js.map

package/dist/generators/ts/ObjectIntersectionType.d.ts

@@ -0,0 +1,44 @@
+import type { Maybe } from "purify-ts";
+import { ObjectIntersectionType_fromJsonObjectFunctionExpression, ObjectIntersectionType_fromJsonObjectFunctionType } from "./_ObjectIntersectionType/ObjectIntersectionType_fromJsonObjectFunction.js";
+import { ObjectIntersectionType_fromRdfResourceValuesFunctionExpression, ObjectIntersectionType_fromRdfResourceValuesFunctionType } from "./_ObjectIntersectionType/ObjectIntersectionType_fromRdfResourceValuesFunction.js";
+import { ObjectIntersectionType_toJsonObjectFunctionExpression } from "./_ObjectIntersectionType/ObjectIntersectionType_toJsonObjectFunction.js";
+import { ObjectIntersectionType_toRdfResourceValuesFunctionExpression } from "./_ObjectIntersectionType/ObjectIntersectionType_toRdfResourceValuesFunction.js";
+import { AbstractIntersectionType } from "./AbstractIntersectionType.js";
+import type { BlankNodeType } from "./BlankNodeType.js";
+import type { Callable } from "./Callable.js";
+import type { IdentifierType } from "./IdentifierType.js";
+import type { IriType } from "./IriType.js";
+import type { ObjectType } from "./ObjectType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class ObjectIntersectionType extends AbstractIntersectionType<ObjectType> {
+    protected fromJsonObjectFunctionExpression: typeof ObjectIntersectionType_fromJsonObjectFunctionExpression;
+    protected fromJsonObjectFunctionType: typeof ObjectIntersectionType_fromJsonObjectFunctionType;
+    protected fromRdfResourceValuesFunctionExpression: typeof ObjectIntersectionType_fromRdfResourceValuesFunctionExpression;
+    protected fromRdfResourceValuesFunctionType: typeof ObjectIntersectionType_fromRdfResourceValuesFunctionType;
+    protected toJsonObjectFunctionExpression: typeof ObjectIntersectionType_toJsonObjectFunctionExpression;
+    protected toRdfResourceValuesFunctionExpression: typeof ObjectIntersectionType_toRdfResourceValuesFunctionExpression;
+    readonly discriminatedType: Maybe<AbstractIntersectionType.DiscriminatedType>;
+    readonly identifierType: BlankNodeType | IdentifierType | IriType;
+    readonly kind = "ObjectIntersection";
+    constructor({ identifierType, ...superParameters }: {
+        identifierType: BlankNodeType | IdentifierType | IriType;
+    } & ConstructorParameters<typeof AbstractIntersectionType<ObjectType>>[0]);
+    get _fromRdfResourceFunction(): Callable;
+    get _toRdfResourceFunction(): Callable;
+    get createFunction(): Callable;
+    get createFunctionParameters(): ObjectType.CreateFunctionParameters;
+    get focusSparqlConstructTriplesFunction(): Callable;
+    get focusSparqlWherePatternsFunction(): Callable;
+    get fromRdfResourceFunction(): Callable;
+    get identifierTypeAlias(): Code;
+    get jsonObjectType(): AbstractIntersectionType<ObjectType>["jsonObjectType"];
+    get jsonValueType(): AbstractIntersectionType<ObjectType>["jsonValueType"];
+    get objectSetMethodNames(): ObjectType.ObjectSetMethodNames;
+    get sparqlConstructQueryFunction(): Callable;
+    get sparqlConstructQueryStringFunction(): Callable;
+    get toRdfResourceFunction(): Callable;
+    get typeGuardFunction(): Maybe<Callable>;
+    protected get createUnsafeFunction(): Callable;
+    protected staticModuleDeclarations(name: string): Record<string, Code>;
+}
+//# sourceMappingURL=ObjectIntersectionType.d.ts.map