@shaclmate/compiler 4.0.35 → 4.0.37

package/dist/generators/ts/{rdfjsDatasetObjectSetClassDeclaration.js → RdfjsDatasetObjectSetType.js}

@@ -1,23 +1,30 @@
-import { objectSetMethodSignatures } from "./objectSetMethodSignatures.js";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Memoize } from "typescript-memoize";
+import { AbstractObjectSetType } from "./AbstractObjectSetType.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
-import { unsupportedObjectSetMethodDeclarations } from "./unsupportedObjectSetMethodDeclarations.js";
-export function rdfjsDatasetObjectSetClassDeclaration({ namedObjectTypes, namedObjectUnionTypes, }) {
-    const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
-    const namedObjectTypeType = code `\
+export class RdfjsDatasetObjectSetType extends AbstractObjectSetType {
+    get declaration() {
+        const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
+        const namedObjectTypeType = code `\
 {
   filter: (filter: ObjectFilterT, value: ObjectT) => boolean;
   fromRdfResource: ${this.reusables.snippets.FromRdfResourceFunction}<ObjectT>;
   fromRdfTypes: readonly ${this.reusables.imports.NamedNode}[]
 }`;
-    const parameters = {
-        query: `query?: ${syntheticNamePrefix}ObjectSet.Query<ObjectFilterT, ObjectIdentifierT>`,
-    };
-    const typeParameters = {
-        ObjectT: code `ObjectT extends { readonly $identifier: () => ObjectIdentifierT }`,
-        ObjectFilterT: code `ObjectFilterT`,
-        ObjectIdentifierT: code `ObjectIdentifierT extends ${this.reusables.imports.BlankNode} | ${this.reusables.imports.NamedNode}`,
-    };
-    return code `\
+        const parameters = {
+            query: `query?: ${syntheticNamePrefix}ObjectSet.Query<ObjectFilterT, ObjectIdentifierT>`,
+        };
+        const typeParameters = {
+            ObjectT: code `ObjectT extends { readonly $identifier: () => ObjectIdentifierT }`,
+            ObjectFilterT: code `ObjectFilterT`,
+            ObjectIdentifierT: code `ObjectIdentifierT extends ${this.reusables.imports.BlankNode} | ${this.reusables.imports.NamedNode}`,
+        };
+        return code `\
 export class ${syntheticNamePrefix}RdfjsDatasetObjectSet implements ${syntheticNamePrefix}ObjectSet {
   readonly #dataset: ${this.reusables.imports.DatasetCore} | (() => ${this.reusables.imports.DatasetCore});
   readonly #graph?: Exclude<${this.reusables.imports.Quad_Graph}, ${this.reusables.imports.Variable}>;
@@ -39,81 +46,74 @@ export class ${syntheticNamePrefix}RdfjsDatasetObjectSet implements ${syntheticN
   }
 
   ${joinCode([
-        ...[...namedObjectTypes, ...namedObjectUnionTypes].flatMap((namedObjectType) => {
-            if (!this.configuration.features.has("rdf")) {
-                return Object.values(unsupportedObjectSetMethodDeclarations.call(this, {
-                    namedObjectType,
-                }));
-            }
-            const methodSignatures = objectSetMethodSignatures.call(this, {
-                namedObjectType,
-            });
-            const delegatingMethods = [
-                // object
-                code `\
+            ...[...this.namedObjectTypes, ...this.namedObjectUnionTypes].flatMap((namedObjectType) => {
+                const methodSignatures = this.methodSignatures(namedObjectType);
+                const delegatingMethods = [
+                    // object
+                    code `\
 async ${methodSignatures.object.name}(${methodSignatures.object.parameters}): ${methodSignatures.object.returnType} {
   return this.${methodSignatures.object.name}Sync(identifier, options);
 }`,
-                // objectSync
-                code `\
+                    // objectSync
+                    code `\
 ${methodSignatures.object.name}Sync(${methodSignatures.object.parameters}): ${this.reusables.imports.Either}<Error, ${namedObjectType.name}> {
   return this.${methodSignatures.objects.name}Sync({ identifiers: [identifier], preferredLanguages: options?.preferredLanguages }).map(objects => objects[0]);
 }`,
-                // objectCount
-                code `\
+                    // objectCount
+                    code `\
 async ${methodSignatures.objectCount.name}(${methodSignatures.objectCount.parameters}): ${methodSignatures.objectCount.returnType} {
   return this.${methodSignatures.objectCount.name}Sync(query);
 }`,
-                // objectCountSync
-                code `\
+                    // objectCountSync
+                    code `\
 ${methodSignatures.objectCount.name}Sync(${methodSignatures.objectCount.parameters}): ${this.reusables.imports.Either}<Error, number> {
   return this.${methodSignatures.objects.name}Sync(query).map(objects => objects.length);
 }`,
-                // objectIdentifiers
-                code `\
+                    // objectIdentifiers
+                    code `\
 async ${methodSignatures.objectIdentifiers.name}(${methodSignatures.objectIdentifiers.parameters}): ${methodSignatures.objectIdentifiers.returnType} {
   return this.${methodSignatures.objectIdentifiers.name}Sync(query);
 }`,
-                // objectIdentifiersSync
-                code `\
+                    // objectIdentifiersSync
+                    code `\
 ${methodSignatures.objectIdentifiers.name}Sync(${methodSignatures.objectIdentifiers.parameters}): ${this.reusables.imports.Either}<Error, readonly ${namedObjectType.identifierTypeAlias}[]> {
   return this.${methodSignatures.objects.name}Sync(query).map(objects => objects.map(object => object.${syntheticNamePrefix}identifier()));
 }`,
-                // objects
-                code `\
+                    // objects
+                    code `\
 async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}): ${methodSignatures.objects.returnType} {
   return this.${methodSignatures.objects.name}Sync(query);
 }`,
-                // objectsSync has per-object type logic, not just forwarding
-            ];
-            const runtimeObjectType = (filterFunction, namedObjectType) => {
-                const fromRdfTypes = namedObjectType.fromRdfTypeVariable
-                    .toList()
-                    .concat(namedObjectType.descendantFromRdfTypeVariables);
-                return code `{ filter: ${filterFunction}, fromRdfResource: ${namedObjectType.name}.fromRdfResource, fromRdfTypes: ${fromRdfTypes.length > 0 ? code `[${joinCode(fromRdfTypes, { on: ", " })}]` : "[]"} }`;
-            };
-            switch (namedObjectType.kind) {
-                case "NamedObjectType": {
-                    return delegatingMethods.concat(code `\
+                    // objectsSync has per-object type logic, not just forwarding
+                ];
+                const runtimeObjectType = (filterFunction, namedObjectType) => {
+                    const fromRdfTypes = namedObjectType.fromRdfTypeVariable
+                        .toList()
+                        .concat(namedObjectType.descendantFromRdfTypeVariables);
+                    return code `{ filter: ${filterFunction}, fromRdfResource: ${namedObjectType.name}.fromRdfResource, fromRdfTypes: ${fromRdfTypes.length > 0 ? code `[${joinCode(fromRdfTypes, { on: ", " })}]` : "[]"} }`;
+                };
+                switch (namedObjectType.kind) {
+                    case "NamedObjectType": {
+                        return delegatingMethods.concat(code `\
 ${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${this.reusables.imports.Either}<Error, readonly ${namedObjectType.name}[]> {
   return this.#objectsSync<${namedObjectType.name}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType(namedObjectType.filterFunction, namedObjectType)}, query);
 }`);
-                }
-                case "NamedObjectUnionType":
-                    return delegatingMethods.concat(code `\
+                    }
+                    case "NamedObjectUnionType":
+                        return delegatingMethods.concat(code `\
 ${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${this.reusables.imports.Either}<Error, readonly ${namedObjectType.name}[]> {
   return this.#objectUnionsSync<${namedObjectType.name}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>([
     ${joinCode(namedObjectType.members.map((member) => runtimeObjectType(namedObjectType.filterFunction, member.type)), { on: ", " })}
   ], query);
 }`);
-                default:
-                    namedObjectType;
-                    return [];
-            }
-        }),
-        ...(namedObjectTypes.length > 0
-            ? [
-                code `\
+                    default:
+                        namedObjectType;
+                        return [];
+                }
+            }),
+            ...(this.namedObjectTypes.length > 0
+                ? [
+                    code `\
 #objectsSync<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(namedObjectType: ${namedObjectTypeType}, ${parameters.query}): ${this.reusables.imports.Either}<Error, readonly ObjectT[]> {
   const graph = query?.graph ?? this.#graph;
 
@@ -201,11 +201,11 @@ ${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${
   }
   return ${this.reusables.imports.Right}(objects);
   }`,
-            ]
-            : []),
-        ...(namedObjectUnionTypes.length > 0
-            ? [
-                code `\
+                ]
+                : []),
+            ...(this.namedObjectUnionTypes.length > 0
+                ? [
+                    code `\
 #objectUnionsSync<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(namedObjectTypes: readonly ${namedObjectTypeType}[], ${parameters.query}): ${this.reusables.imports.Either}<Error, readonly ObjectT[]> {
   const graph = query?.graph ?? this.#graph;
 
@@ -314,9 +314,13 @@ ${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${
   }
   return ${this.reusables.imports.Right}(objects);
 }`,
-            ]
-            : []),
-    ], { on: "\n\n" })}
+                ]
+                : []),
+        ], { on: "\n\n" })}
 }`;
+    }
 }
-//# sourceMappingURL=rdfjsDatasetObjectSetClassDeclaration.js.map
+__decorate([
+    Memoize()
+], RdfjsDatasetObjectSetType.prototype, "declaration", null);
+//# sourceMappingURL=RdfjsDatasetObjectSetType.js.map

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

@@ -124,6 +124,7 @@ export declare class Snippets {
     get maybeEquals(): Snippet;
     get maybeSparqlConstructTriples(): Snippet;
     get maybeSparqlWherePatterns(): Snippet;
+    get monkeyPatchObject(): Snippet;
     get normalizeSparqlWherePatterns(): Snippet;
     get numericSparqlWherePatterns(): Snippet;
     get parseBlankNode(): Snippet;

package/dist/generators/ts/Snippets.js

@@ -99,6 +99,7 @@ import { snippets_MaybeSchema } from "./_snippets/snippets_MaybeSchema.js";
 import { snippets_maybeEquals } from "./_snippets/snippets_maybeEquals.js";
 import { snippets_maybeSparqlConstructTriples } from "./_snippets/snippets_maybeSparqlConstructTriples.js";
 import { snippets_maybeSparqlWherePatterns } from "./_snippets/snippets_maybeSparqlWherePatterns.js";
+import { snippets_monkeyPatchObject } from "./_snippets/snippets_monkeyPatchObject.js";
 import { snippets_NumericFilter } from "./_snippets/snippets_NumericFilter.js";
 import { snippets_NumericSchema } from "./_snippets/snippets_NumericSchema.js";
 import { snippets_normalizeSparqlWherePatterns } from "./_snippets/snippets_normalizeSparqlWherePatterns.js";
@@ -505,6 +506,9 @@ export class Snippets {
     get maybeSparqlWherePatterns() {
         return this.snippet(snippets_maybeSparqlWherePatterns);
     }
+    get monkeyPatchObject() {
+        return this.snippet(snippets_monkeyPatchObject);
+    }
     get normalizeSparqlWherePatterns() {
         return this.snippet(snippets_normalizeSparqlWherePatterns);
     }
@@ -931,6 +935,9 @@ __decorate([
 __decorate([
     Memoize()
 ], Snippets.prototype, "maybeSparqlWherePatterns", null);
+__decorate([
+    Memoize()
+], Snippets.prototype, "monkeyPatchObject", null);
 __decorate([
     Memoize()
 ], Snippets.prototype, "normalizeSparqlWherePatterns", null);

package/dist/generators/ts/SparqlObjectSetType.d.ts

@@ -0,0 +1,6 @@
+import { AbstractObjectSetType } from "./AbstractObjectSetType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class SparqlObjectSetType extends AbstractObjectSetType {
+    get declaration(): Code;
+}
+//# sourceMappingURL=SparqlObjectSetType.d.ts.map

package/dist/generators/ts/{sparqlObjectSetClassDeclaration.js → SparqlObjectSetType.js}

@@ -1,24 +1,31 @@
-import { objectSetMethodSignatures } from "./objectSetMethodSignatures.js";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Memoize } from "typescript-memoize";
+import { AbstractObjectSetType } from "./AbstractObjectSetType.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
-import { unsupportedObjectSetMethodDeclarations } from "./unsupportedObjectSetMethodDeclarations.js";
-export function sparqlObjectSetClassDeclaration({ namedObjectTypes, namedObjectUnionTypes, }) {
-    const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
-    const parameters = {
-        constructObjectType: code `namedObjectType: {\
+export class SparqlObjectSetType extends AbstractObjectSetType {
+    get declaration() {
+        const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
+        const parameters = {
+            constructObjectType: code `namedObjectType: {\
   focusSparqlWherePatterns: ${this.reusables.snippets.FocusSparqlWherePatternsFunction}<ObjectFilterT>;
   fromRdfResource:  ${this.reusables.snippets.FromRdfResourceFunction}<ObjectT>;
   sparqlConstructQueryString: (parameters: { filter?: ObjectFilterT; subject: ${this.reusables.imports.NamedNode} | ${this.reusables.imports.Variable}; } & Omit<${this.reusables.imports.sparqljs}.ConstructQuery, "prefixes" | "queryType" | "type"> & ${this.reusables.imports.sparqljs}.GeneratorOptions) => string;
 }`,
-        query: code `query?: ${syntheticNamePrefix}SparqlObjectSet.Query<ObjectFilterT, ObjectIdentifierT>`,
-        selectObjectTypeType: code `namedObjectType: { focusSparqlWherePatterns: ${this.reusables.snippets.FocusSparqlWherePatternsFunction}<ObjectFilterT> }`,
-    };
-    const sparqlClientType = code `{ queryBindings: (query: string) => Promise<readonly Record<string, ${this.reusables.imports.BlankNode} | ${this.reusables.imports.Literal} | ${this.reusables.imports.NamedNode}>[]>; queryQuads: (query: string) => Promise<readonly ${this.reusables.imports.Quad}[]>; }`;
-    const typeParameters = {
-        ObjectT: code `ObjectT extends { readonly $identifier: () => ObjectIdentifierT }`,
-        ObjectFilterT: code `ObjectFilterT`,
-        ObjectIdentifierT: code `ObjectIdentifierT extends ${this.reusables.imports.BlankNode} | ${this.reusables.imports.NamedNode}`,
-    };
-    return code `\
+            query: code `query?: ${syntheticNamePrefix}SparqlObjectSet.Query<ObjectFilterT, ObjectIdentifierT>`,
+            selectObjectTypeType: code `namedObjectType: { focusSparqlWherePatterns: ${this.reusables.snippets.FocusSparqlWherePatternsFunction}<ObjectFilterT> }`,
+        };
+        const sparqlClientType = code `{ queryBindings: (query: string) => Promise<readonly Record<string, ${this.reusables.imports.BlankNode} | ${this.reusables.imports.Literal} | ${this.reusables.imports.NamedNode}>[]>; queryQuads: (query: string) => Promise<readonly ${this.reusables.imports.Quad}[]>; }`;
+        const typeParameters = {
+            ObjectT: code `ObjectT extends { readonly $identifier: () => ObjectIdentifierT }`,
+            ObjectFilterT: code `ObjectFilterT`,
+            ObjectIdentifierT: code `ObjectIdentifierT extends ${this.reusables.imports.BlankNode} | ${this.reusables.imports.NamedNode}`,
+        };
+        return code `\
 export class ${syntheticNamePrefix}SparqlObjectSet implements ${syntheticNamePrefix}ObjectSet {
   readonly #countVariable = ${this.reusables.imports.dataFactory}.variable!("count");;
   readonly #graph?: Exclude<${this.reusables.imports.Quad_Graph}, ${this.reusables.imports.Variable}>;
@@ -31,36 +38,30 @@ export class ${syntheticNamePrefix}SparqlObjectSet implements ${syntheticNamePre
     this.#sparqlClient = sparqlClient;
   }
 
-${joinCode([...namedObjectTypes, ...namedObjectUnionTypes].flatMap((namedObjectType) => {
-        if (!this.configuration.features.has("sparql")) {
-            return Object.values(unsupportedObjectSetMethodDeclarations.call(this, {
-                namedObjectType,
-            }));
-        }
-        const methodSignatures = objectSetMethodSignatures.call(this, {
-            namedObjectType,
-            queryT: `${syntheticNamePrefix}SparqlObjectSet.Query`,
-        });
-        const runtimeObjectType = namedObjectType.name;
-        return [
-            code `\
+${joinCode([...this.namedObjectTypes, ...this.namedObjectUnionTypes].flatMap((namedObjectType) => {
+            const methodSignatures = this.methodSignatures(namedObjectType, {
+                queryT: `${syntheticNamePrefix}SparqlObjectSet.Query`,
+            });
+            const runtimeObjectType = namedObjectType.name;
+            return [
+                code `\
 async ${methodSignatures.object.name}(${methodSignatures.object.parameters}): ${methodSignatures.object.returnType} {
   return (await this.${methodSignatures.objects.name}({ identifiers: [identifier], preferredLanguages: options?.preferredLanguages })).map(objects => objects[0]);
 }`,
-            code `\
+                code `\
 async ${methodSignatures.objectCount.name}(${methodSignatures.objectCount.parameters}): ${methodSignatures.objectCount.returnType} {
   return this.#objectCount<${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType}, query);
 }`,
-            code `\
+                code `\
 async ${methodSignatures.objectIdentifiers.name}(${methodSignatures.objectIdentifiers.parameters}): ${methodSignatures.objectIdentifiers.returnType} {
   return this.#objectIdentifiers<${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType}, query);
 }`,
-            code `\
+                code `\
 async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}): ${methodSignatures.objects.returnType} {
   return this.#objects<${namedObjectType.name}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType}, query);
 }`,
-        ];
-    }), { on: "\n\n" })}
+            ];
+        }), { on: "\n\n" })}
 
   #mapBindingsToCount(bindings: readonly Record<string, ${this.reusables.imports.BlankNode} | ${this.reusables.imports.Literal} | ${this.reusables.imports.NamedNode}>[], variable: string): ${this.reusables.imports.Either}<Error, number> {
     if (bindings.length === 0) {
@@ -232,5 +233,9 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
 export namespace ${syntheticNamePrefix}SparqlObjectSet {
   export type Query<${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}> = ${syntheticNamePrefix}ObjectSet.Query<ObjectFilterT, ObjectIdentifierT> & { readonly order?: (objectVariable: ${this.reusables.imports.Variable}) => readonly ${this.reusables.imports.sparqljs}.Ordering[]; readonly where?: (objectVariable: ${this.reusables.imports.Variable}) => readonly ${this.reusables.imports.sparqljs}.Pattern[] };
 }`;
+    }
 }
-//# sourceMappingURL=sparqlObjectSetClassDeclaration.js.map
+__decorate([
+    Memoize()
+], SparqlObjectSetType.prototype, "declaration", null);
+//# sourceMappingURL=SparqlObjectSetType.js.map

package/dist/generators/ts/TsFeature.d.ts

@@ -1,3 +1,3 @@
 export type TsFeature = (typeof TS_FEATURES)[number];
-export declare const TS_FEATURES: readonly ["create", "equals", "graphql", "hash", "json", "rdf", "sparql"];
+export declare const TS_FEATURES: readonly ["GraphQL", "JSON", "Object.create", "Object.equals", "Object.filter", "Object.fromJson", "Object.fromRdf", "Object.hash", "Object.JSON", "Object.JSON.type", "Object.JSON.parse", "Object.JSON.schema", "Object.JSON.uiSchema", "Object.RDF", "Object.schema", "Object.SPARQL", "Object.toJson", "Object.toRdf", "Object.toString", "Object.type", "ObjectSet", "RDF", "RdfjsDatasetObjectSet", "SPARQL", "SparqlObjectSet"];
 //# sourceMappingURL=TsFeature.d.ts.map

package/dist/generators/ts/TsFeature.js

@@ -1,10 +1,28 @@
 export const TS_FEATURES = [
-    "create",
-    "equals",
-    "graphql",
-    "hash",
-    "json",
-    "rdf",
-    "sparql",
+    "GraphQL",
+    "JSON",
+    "Object.create",
+    "Object.equals",
+    "Object.filter",
+    "Object.fromJson",
+    "Object.fromRdf",
+    "Object.hash",
+    "Object.JSON",
+    "Object.JSON.type",
+    "Object.JSON.parse",
+    "Object.JSON.schema",
+    "Object.JSON.uiSchema",
+    "Object.RDF",
+    "Object.schema",
+    "Object.SPARQL",
+    "Object.toJson",
+    "Object.toRdf",
+    "Object.toString",
+    "Object.type",
+    "ObjectSet",
+    "RDF",
+    "RdfjsDatasetObjectSet",
+    "SPARQL",
+    "SparqlObjectSet",
 ];
 //# sourceMappingURL=TsFeature.js.map

package/dist/generators/ts/TsGenerator.d.ts

@@ -1,18 +1,16 @@
 import type { Logger } from "ts-log";
 import * as ast from "../../ast/index.js";
 import type { Generator } from "../Generator.js";
-import { Reusables } from "./Reusables.js";
 import type { TsFeature } from "./TsFeature.js";
 export declare class TsGenerator implements Generator {
-    private readonly typeFactory;
-    protected readonly configuration: TsGenerator.Configuration;
-    protected readonly logger: Logger;
-    protected readonly reusables: Reusables;
+    private readonly configuration?;
+    private readonly logger;
     constructor({ configuration, logger, }: {
-        configuration?: TsGenerator.Configuration;
+        configuration?: Partial<TsGenerator.Configuration>;
         logger: Logger;
     });
     generate(ast_: ast.Ast): string;
+    private objectSetTypeDeclarations;
     /**
      * Synthesize the $Object union.
      */
@@ -21,11 +19,12 @@ export declare class TsGenerator implements Generator {
 export declare namespace TsGenerator {
     interface Configuration {
         readonly features: ReadonlySet<TsFeature>;
+        readonly finalized: true;
         readonly syntheticNamePrefix: string;
     }
     namespace Configuration {
-        const default_: Configuration;
-        function inferFeatures(features: ReadonlySet<TsFeature>): Set<"equals" | "create" | "graphql" | "hash" | "json" | "rdf" | "sparql">;
+        const default_: Omit<Configuration, "finalized">;
+        function finalize(ast: ast.Ast, partialConfiguration?: Partial<Configuration>): Configuration;
     }
 }
 //# sourceMappingURL=TsGenerator.d.ts.map