@shaclmate/compiler 4.0.35 → 4.0.37

package/dist/ShapesGraphToAstTransformer.js

@@ -143,6 +143,16 @@ export class ShapesGraphToAstTransformer {
             }
         }
         return Either.of({
+            lazyTypesCount: [...this.cachedAstTypesByShapeIdentifier.values()].reduce((acc, astType) => {
+                switch (astType.kind) {
+                    case "LazyObjectType":
+                    case "LazyObjectOptionType":
+                    case "LazyObjectSetType":
+                        return acc + 1;
+                    default:
+                        return acc;
+                }
+            }, 0),
             namedIntersectionTypes: astNamedIntersectionTypes,
             namedObjectTypes: astObjectTypes.concat(Object.values(syntheticAstObjectTypesByName)),
             namedUnionTypes: astNamedUnionTypes,

package/dist/ast/Ast.d.ts

@@ -2,6 +2,7 @@ import type { IntersectionType } from "./IntersectionType.js";
 import type { ObjectType } from "./ObjectType.js";
 import type { UnionType } from "./UnionType.js";
 export interface Ast {
+    readonly lazyTypesCount: number;
     readonly namedIntersectionTypes: readonly IntersectionType[];
     readonly namedObjectTypes: readonly ObjectType[];
     readonly namedUnionTypes: readonly UnionType[];

package/dist/generators/ts/AbstractNamedUnionType.js

@@ -16,9 +16,10 @@ export class AbstractNamedUnionType extends AbstractUnionType {
         this._name = name;
     }
     get declaration() {
-        const declarations = [
-            code `export type ${def(this._name)} = ${this.inlineName};`,
-        ];
+        const declarations = [];
+        if (this.configuration.features.has("Object.type")) {
+            declarations.push(code `export type ${def(this._name)} = ${this.inlineName};`);
+        }
         const staticModuleDeclarations = Object.entries(this.staticModuleDeclarations);
         if (staticModuleDeclarations.length > 0) {
             declarations.push(code `\
@@ -68,22 +69,26 @@ ${joinCode(staticModuleDeclarations
     }
     get staticModuleDeclarations() {
         const staticModuleDeclarations = {};
-        if (this.configuration.features.has("equals")) {
+        if (this.configuration.features.has("Object.equals")) {
             staticModuleDeclarations[`equals`] =
                 code `export const equals = ${this.inlineEqualsFunction};`;
         }
-        staticModuleDeclarations[`Filter`] =
-            code `export type Filter = ${this.inlineFilterType};`;
-        staticModuleDeclarations[`filter`] =
-            code `export const filter = ${this.inlineFilterFunction};`;
-        if (this.configuration.features.has("hash")) {
+        if (this.configuration.features.has("Object.filter")) {
+            staticModuleDeclarations[`Filter`] =
+                code `export type Filter = ${this.inlineFilterType};`;
+            staticModuleDeclarations[`filter`] =
+                code `export const filter = ${this.inlineFilterFunction};`;
+        }
+        if (this.configuration.features.has("Object.hash")) {
             staticModuleDeclarations[`hash`] =
                 code `export const hash = ${this.inlineHashFunction};`;
         }
-        if (this.configuration.features.has("json")) {
-            staticModuleDeclarations[`Json`] = code `\
-${this.jsonTypeAliasDeclaration}
-
+        if (this.configuration.features.has("Object.JSON.type")) {
+            staticModuleDeclarations[`Json.type`] =
+                code `${this.jsonTypeAliasDeclaration}`;
+        }
+        if (this.configuration.features.has("Object.JSON.schema")) {
+            staticModuleDeclarations[`Json.namespace`] = code `\
 export namespace Json {
   ${this.jsonSchemaFunctionDeclaration}
 
@@ -93,34 +98,46 @@ export namespace Json {
     return ${this.reusables.imports.Right}(jsonSafeParseResult.data);
   }
 }`;
+        }
+        if (this.configuration.features.has("Object.fromJson")) {
             staticModuleDeclarations[`fromJson`] =
                 code `export const fromJson = ${this.inlineFromJsonFunction};`;
-            staticModuleDeclarations[`toJson`] =
-                code `export const toJson = ${this.inlineToJsonFunction};`;
         }
-        if (this.configuration.features.has("rdf")) {
+        if (this.configuration.features.has("Object.fromRdf")) {
             staticModuleDeclarations[`fromRdfResourceValues`] =
                 code `export const fromRdfResourceValues: ${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.name}> = ${this.inlineFromRdfResourceValuesFunction};`;
+        }
+        if (this.configuration.features.has("Object.toJson")) {
+            staticModuleDeclarations[`toJson`] =
+                code `export const toJson = ${this.inlineToJsonFunction};`;
+        }
+        if (this.configuration.features.has("Object.toRdf")) {
             staticModuleDeclarations[`toRdfResourceValues`] =
                 code `export const toRdfResourceValues = ${this.inlineToRdfResourceValuesFunction};`;
         }
-        if (this.configuration.features.has("sparql")) {
+        if (this.configuration.features.has("Object.SPARQL")) {
             staticModuleDeclarations[`valueSparqlConstructTriples`] =
                 code `export const valueSparqlConstructTriples: ${this.reusables.snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}> = ${this.inlineValueSparqlConstructTriplesFunction};`;
             staticModuleDeclarations[`valueSparqlWherePatterns`] =
                 code `export const valueSparqlWherePatterns: ${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}> = ${this.inlineValueSparqlWherePatternsFunction};`;
         }
-        const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
-        staticModuleDeclarations[`${syntheticNamePrefix}toString`] =
-            code `export const ${syntheticNamePrefix}toString = ${this.inlineToStringFunction};`;
+        if (this.configuration.features.has("Object.toString")) {
+            const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
+            staticModuleDeclarations[`${syntheticNamePrefix}toString`] =
+                code `export const ${syntheticNamePrefix}toString = ${this.inlineToStringFunction};`;
+        }
         return staticModuleDeclarations;
     }
     fromJsonExpression({ variables, }) {
         return code `${this.name}.fromJson(${variables.value})`;
     }
     fromRdfResourceValuesExpression({ variables, }) {
-        const { resourceValues: resourceValuesVariable, ...otherVariables } = variables;
-        return code `${this.name}.fromRdfResourceValues(${resourceValuesVariable}, ${otherVariables})`;
+        const { resourceValues: resourceValuesVariable, ...fromRdfResourceValuesOptionsTemp } = variables;
+        const fromRdfResourceValuesOptions = fromRdfResourceValuesOptionsTemp;
+        if (!this.configuration.features.has("ObjectSet")) {
+            delete fromRdfResourceValuesOptions["objectSet"];
+        }
+        return code `${this.name}.fromRdfResourceValues(${resourceValuesVariable}, ${fromRdfResourceValuesOptions})`;
     }
     jsonSchema({ context, }) {
         const expression = code `${this.name}.Json.schema()`;

package/dist/generators/ts/AbstractObjectSetType.d.ts

@@ -0,0 +1,35 @@
+import type { Logger } from "ts-log";
+import type { NamedObjectType } from "./NamedObjectType.js";
+import type { NamedObjectUnionType } from "./NamedObjectUnionType.js";
+import type { Reusables } from "./Reusables.js";
+import type { TsGenerator } from "./TsGenerator.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare abstract class AbstractObjectSetType {
+    protected readonly configuration: TsGenerator.Configuration;
+    protected readonly logger: Logger;
+    protected readonly reusables: Reusables;
+    protected readonly namedObjectTypes: readonly NamedObjectType[];
+    protected readonly namedObjectUnionTypes: readonly NamedObjectUnionType[];
+    constructor({ configuration, logger, namedObjectTypes, namedObjectUnionTypes, reusables, }: {
+        configuration: TsGenerator.Configuration;
+        logger: Logger;
+        namedObjectTypes: readonly NamedObjectType[];
+        namedObjectUnionTypes: readonly NamedObjectUnionType[];
+        reusables: Reusables;
+    });
+    abstract readonly declaration: Code;
+    protected methodSignatures(namedObjectType: {
+        readonly filterType: Code;
+        readonly identifierTypeAlias: Code;
+        readonly objectSetMethodNames: NamedObjectType.ObjectSetMethodNames;
+        readonly name: string;
+    }, options?: {
+        parameterNamePrefix?: string;
+        queryT?: string;
+    }): Readonly<Record<keyof NamedObjectType.ObjectSetMethodNames, {
+        readonly name: string;
+        readonly parameters: Code;
+        readonly returnType: Code;
+    }>>;
+}
+//# sourceMappingURL=AbstractObjectSetType.d.ts.map

package/dist/generators/ts/AbstractObjectSetType.js

@@ -0,0 +1,44 @@
+import { code } from "./ts-poet-wrapper.js";
+export class AbstractObjectSetType {
+    configuration;
+    logger;
+    reusables;
+    namedObjectTypes;
+    namedObjectUnionTypes;
+    constructor({ configuration, logger, namedObjectTypes, namedObjectUnionTypes, reusables, }) {
+        this.configuration = configuration;
+        this.logger = logger;
+        this.namedObjectTypes = namedObjectTypes;
+        this.namedObjectUnionTypes = namedObjectUnionTypes;
+        this.reusables = reusables;
+    }
+    methodSignatures(namedObjectType, options) {
+        const parameterNamePrefix = options?.parameterNamePrefix ?? "";
+        const queryT = options?.queryT ??
+            `${this.configuration.syntheticNamePrefix}ObjectSet.Query`;
+        const methodNames = namedObjectType.objectSetMethodNames;
+        return {
+            object: {
+                name: methodNames.object,
+                parameters: code `${parameterNamePrefix}identifier: ${namedObjectType.identifierTypeAlias}, options?: { preferredLanguages?: readonly string[]; }`,
+                returnType: code `Promise<${this.reusables.imports.Either}<Error, ${namedObjectType.name}>>`,
+            },
+            objectCount: {
+                name: methodNames.objectCount,
+                parameters: code `${parameterNamePrefix}query?: Pick<${queryT}<${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>, "filter">`,
+                returnType: code `Promise<${this.reusables.imports.Either}<Error, number>>`,
+            },
+            objectIdentifiers: {
+                name: methodNames.objectIdentifiers,
+                parameters: code `${parameterNamePrefix}query?: ${queryT}<${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>`,
+                returnType: code `Promise<${this.reusables.imports.Either}<Error, readonly ${namedObjectType.identifierTypeAlias}[]>>`,
+            },
+            objects: {
+                name: methodNames.objects,
+                parameters: code `${parameterNamePrefix}query?: ${queryT}<${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>`,
+                returnType: code `Promise<${this.reusables.imports.Either}<Error, readonly ${namedObjectType.name}[]>>`,
+            },
+        };
+    }
+}
+//# sourceMappingURL=AbstractObjectSetType.js.map

package/dist/generators/ts/GraphqlSchema.d.ts

@@ -0,0 +1,22 @@
+import type { Logger } from "ts-log";
+import type { NamedObjectType } from "./NamedObjectType.js";
+import type { NamedObjectUnionType } from "./NamedObjectUnionType.js";
+import type { Reusables } from "./Reusables.js";
+import type { TsGenerator } from "./TsGenerator.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class GraphqlSchema {
+    private readonly configuration;
+    private readonly reusables;
+    private readonly namedObjectTypes;
+    private readonly namedObjectUnionTypes;
+    constructor({ configuration, namedObjectTypes, namedObjectUnionTypes, reusables, }: {
+        configuration: TsGenerator.Configuration;
+        logger: Logger;
+        namedObjectTypes: readonly NamedObjectType[];
+        namedObjectUnionTypes: readonly NamedObjectUnionType[];
+        reusables: Reusables;
+    });
+    get declaration(): Code;
+    private get graphqlQueryObjectType();
+}
+//# sourceMappingURL=GraphqlSchema.d.ts.map

package/dist/generators/ts/GraphqlSchema.js

@@ -0,0 +1,87 @@
+import { code } from "./ts-poet-wrapper.js";
+export class GraphqlSchema {
+    configuration;
+    reusables;
+    namedObjectTypes;
+    namedObjectUnionTypes;
+    constructor({ configuration, namedObjectTypes, namedObjectUnionTypes, reusables, }) {
+        this.configuration = configuration;
+        this.namedObjectTypes = namedObjectTypes;
+        this.namedObjectUnionTypes = namedObjectUnionTypes;
+        this.reusables = reusables;
+    }
+    get declaration() {
+        return code `\
+export const graphqlSchema = new ${this.reusables.imports.GraphQLSchema}({ query: ${this.graphqlQueryObjectType} });
+`;
+    }
+    get graphqlQueryObjectType() {
+        const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
+        return code `new ${this.reusables.imports.GraphQLObjectType}<null, { objectSet: ${syntheticNamePrefix}ObjectSet }>({ name: "Query", fields: ${[
+            ...this.namedObjectTypes,
+            ...this.namedObjectUnionTypes,
+        ].reduce((fields, namedObjectType) => {
+            fields[namedObjectType.objectSetMethodNames.object] = {
+                args: {
+                    identifier: {
+                        type: code `new ${this.reusables.imports.GraphQLNonNull}(${this.reusables.imports.GraphQLID})`,
+                    },
+                },
+                resolve: code `\
+  async (_source, args: { identifier: string }, { objectSet }): Promise<${namedObjectType.name}> => 
+    (await ${this.reusables.imports.EitherAsync}<Error, ${namedObjectType.name}>(async ({ liftEither }) => 
+      liftEither(await objectSet.${namedObjectType.objectSetMethodNames.object}(await liftEither(${namedObjectType.identifierTypeAlias}.parse(args.identifier))))
+    )).unsafeCoerce()`,
+                type: namedObjectType.graphqlType.name,
+            };
+            fields[namedObjectType.objectSetMethodNames.objectIdentifiers] = {
+                args: {
+                    limit: {
+                        type: code `${this.reusables.imports.GraphQLInt}`,
+                    },
+                    offset: {
+                        type: code `${this.reusables.imports.GraphQLInt}`,
+                    },
+                },
+                resolve: code `\
+   async (_source, args: { limit: number | null; offset: number | null; }, { objectSet }): Promise<readonly string[]> =>
+    (await objectSet.${namedObjectType.objectSetMethodNames.objectIdentifiers}({ limit: args.limit !== null ? args.limit : undefined, offset: args.offset !== null ? args.offset : undefined })).unsafeCoerce().map(${namedObjectType.identifierTypeAlias}.stringify)`,
+                type: code `new ${this.reusables.imports.GraphQLNonNull}(new ${this.reusables.imports.GraphQLList}(${this.reusables.imports.GraphQLString}))`,
+            };
+            fields[namedObjectType.objectSetMethodNames.objects] = {
+                args: {
+                    identifiers: {
+                        type: code `new ${this.reusables.imports.GraphQLList}(new ${this.reusables.imports.GraphQLNonNull}(${this.reusables.imports.GraphQLID}))`,
+                    },
+                    limit: {
+                        type: code `${this.reusables.imports.GraphQLInt}`,
+                    },
+                    offset: {
+                        type: code `${this.reusables.imports.GraphQLInt}`,
+                    },
+                },
+                resolve: code `\
+  async (_source, args: { identifiers: readonly string[] | null; limit: number | null; offset: number | null; }, { objectSet }): Promise<readonly ${namedObjectType.name}[]> =>
+  (await ${this.reusables.imports.EitherAsync}<Error, readonly ${namedObjectType.name}[]>(async ({ liftEither }) => {
+    let filter: ${namedObjectType.filterType} | undefined;
+    if (args.identifiers) {
+      const identifiers: ${namedObjectType.identifierTypeAlias}[] = [];
+      for (const identifierArg of args.identifiers) {
+        identifiers.push(await liftEither(${namedObjectType.identifierTypeAlias}.parse(identifierArg)));
+      }
+      filter = { ${syntheticNamePrefix}identifier: { in: identifiers } };
+    }
+    return await liftEither(await objectSet.${namedObjectType.objectSetMethodNames.objects}({ filter, limit: args.limit !== null ? args.limit : undefined, offset: args.offset !== null ? args.offset : undefined }));
+  })).unsafeCoerce()`,
+                type: code `new ${this.reusables.imports.GraphQLNonNull}(new ${this.reusables.imports.GraphQLList}(${namedObjectType.graphqlType.name}))`,
+            };
+            fields[namedObjectType.objectSetMethodNames.objectCount] = {
+                resolve: code `\
+  async (_source, _args, { objectSet }): Promise<number> => (await objectSet.${namedObjectType.objectSetMethodNames.objectCount}()).unsafeCoerce()`,
+                type: code `new ${this.reusables.imports.GraphQLNonNull}(${this.reusables.imports.GraphQLInt})`,
+            };
+            return fields;
+        }, {})} })`;
+    }
+}
+//# sourceMappingURL=GraphqlSchema.js.map

package/dist/generators/ts/NamedObjectType.js

@@ -84,7 +84,9 @@ export class NamedObjectType extends AbstractType {
         const declarations = [];
         if (!this.extern) {
             const staticModuleDeclarations = [];
-            declarations.push(NamedObjectType_interfaceDeclaration.call(this));
+            if (this.configuration.features.has("Object.type")) {
+                declarations.push(NamedObjectType_interfaceDeclaration.call(this));
+            }
             staticModuleDeclarations.push(...NamedObjectType_createFunctionDeclaration.call(this).toList(), ...NamedObjectType_equalsFunctionDeclaration.call(this).toList(), ...NamedObjectType_hashFunctionDeclarations.call(this));
             const jsonModuleDeclarations = [
                 ...NamedObjectType_jsonParseFunctionDeclaration.call(this).toList(),
@@ -95,7 +97,7 @@ export class NamedObjectType extends AbstractType {
                 ? [
                     code `export namespace Json { ${joinCode(jsonModuleDeclarations, { on: "\n\n" })} }`,
                 ]
-                : []), NamedObjectType_filterFunctionDeclaration.call(this), NamedObjectType_filterTypeDeclaration.call(this), ...NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration.call(this).toList(), ...NamedObjectType_focusSparqlWherePatternsFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromJsonFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfResourceFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfResourceValuesFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfTypeVariableStatement.call(this).toList(), NamedObjectType_isTypeFunctionDeclaration.call(this), NamedObjectType_schemaVariableStatement.call(this), ...NamedObjectType_sparqlConstructQueryFunctionDeclaration.call({
+                : []), ...NamedObjectType_filterFunctionDeclaration.call(this).toList(), ...NamedObjectType_filterTypeDeclaration.call(this).toList(), ...NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration.call(this).toList(), ...NamedObjectType_focusSparqlWherePatternsFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromJsonFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfResourceFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfResourceValuesFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfTypeVariableStatement.call(this).toList(), ...NamedObjectType_isTypeFunctionDeclaration.call(this).toList(), ...NamedObjectType_schemaVariableStatement.call(this).toList(), ...NamedObjectType_sparqlConstructQueryFunctionDeclaration.call({
                 configuration: this.configuration,
                 filterType: this.filterType,
                 name: this.name,
@@ -113,6 +115,9 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
 }`);
             }
         }
+        if (declarations.length === 0) {
+            return Maybe.empty();
+        }
         return Maybe.of(joinCode(declarations, { on: "\n\n" }));
     }
     get descendantFromRdfTypeVariables() {
@@ -207,8 +212,12 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
         return code `${this.name}.fromJson(${variables.value})`;
     }
     fromRdfResourceValuesExpression({ variables, }) {
-        const { resourceValues, ...options } = variables;
-        return code `${this.name}.fromRdfResourceValues(${resourceValues}, ${options})`;
+        const { resourceValues: resourceValuesVariable, ...fromRdfResourceValuesOptionsTemp } = variables;
+        const fromRdfResourceValuesOptions = fromRdfResourceValuesOptionsTemp;
+        if (!this.configuration.features.has("ObjectSet")) {
+            delete fromRdfResourceValuesOptions["objectSet"];
+        }
+        return code `${this.name}.fromRdfResourceValues(${resourceValuesVariable}, ${fromRdfResourceValuesOptions})`;
     }
     graphqlResolveExpression({ variables, }) {
         return variables.value;

package/dist/generators/ts/NamedObjectUnionType.js

@@ -73,7 +73,7 @@ export class NamedObjectUnionType extends AbstractNamedUnionType {
         };
     }
     get focusSparqlConstructTriplesFunctionDeclaration() {
-        if (!this.configuration.features.has("sparql")) {
+        if (!this.configuration.features.has("Object.SPARQL")) {
             return {};
         }
         return singleEntryRecord(`focusSparqlConstructTriples`, code `\
@@ -82,7 +82,7 @@ export function focusSparqlConstructTriples({ filter, focusIdentifier, variableP
 }`);
     }
     get focusSparqlWherePatternsFunctionDeclaration() {
-        if (!this.configuration.features.has("sparql")) {
+        if (!this.configuration.features.has("Object.SPARQL")) {
             return {};
         }
         return singleEntryRecord(`focusSparqlWherePatterns`, code `\
@@ -110,7 +110,7 @@ if (focusIdentifier.termType === "Variable") {
 }`);
     }
     get fromRdfResourceFunctionDeclaration() {
-        if (!this.configuration.features.has("rdf")) {
+        if (!this.configuration.features.has("Object.fromRdf")) {
             return {};
         }
         return singleEntryRecord(`fromRdfResource`, code `\
@@ -123,7 +123,7 @@ export const fromRdfResource: ${this.reusables.snippets.FromRdfResourceFunction}
         }, null)};`);
     }
     get graphqlTypeVariableStatement() {
-        if (!this.configuration.features.has("graphql")) {
+        if (!this.configuration.features.has("GraphQL")) {
             return {};
         }
         if (this.synthetic) {
@@ -138,6 +138,9 @@ export const GraphQL = new ${this.reusables.imports.GraphQLUnionType}(${{
         }});`);
     }
     get identifierTypeDeclarations() {
+        if (!this.configuration.features.has("Object.type")) {
+            return {};
+        }
         return singleEntryRecord(`Identifier`, code `\
 export type Identifier = ${this.#identifierType.name};
 export namespace Identifier {
@@ -146,6 +149,9 @@ export namespace Identifier {
 }`);
     }
     get isTypeFunctionDeclaration() {
+        if (!this.configuration.features.has("Object.type")) {
+            return {};
+        }
         if (this._name === `${this.configuration.syntheticNamePrefix}Object`) {
             return {};
         }
@@ -155,6 +161,9 @@ export namespace Identifier {
     }`);
     }
     get schemaVariableStatement() {
+        if (!this.configuration.features.has("Object.schema")) {
+            return {};
+        }
         const commonPropertiesByName = {};
         this.members.forEach((member, memberI) => {
             for (const memberTypeProperty of member.type.properties.concat(member.type.ancestorObjectTypes.flatMap((ancestorObjectType) => ancestorObjectType.properties))) {
@@ -192,7 +201,7 @@ ${{
         }} as const;`);
     }
     get toRdfResourceFunctionDeclaration() {
-        if (!this.configuration.features.has("rdf")) {
+        if (!this.configuration.features.has("Object.toRdf")) {
             return {};
         }
         return singleEntryRecord(`toRdfResource`, code `\

package/dist/generators/ts/ObjectSetType.d.ts

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

package/dist/generators/ts/ObjectSetType.js

@@ -0,0 +1,36 @@
+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";
+export class ObjectSetType extends AbstractObjectSetType {
+    get declaration() {
+        const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
+        return code `\
+export interface ${syntheticNamePrefix}ObjectSet {
+  ${joinCode(this.namedObjectTypes
+            .flatMap((namedObjectType) => Object.values(this.methodSignatures(namedObjectType)))
+            .concat(this.namedObjectUnionTypes.flatMap((namedObjectUnionType) => Object.values(this.methodSignatures(namedObjectUnionType))))
+            .map((methodSignature) => code `${methodSignature.name}(${methodSignature.parameters}): ${methodSignature.returnType};`), { on: "\n\n" })}
+}
+
+export namespace ${syntheticNamePrefix}ObjectSet {
+  export interface Query<ObjectFilterT, ObjectIdentifierT extends ${this.reusables.imports.BlankNode} | ${this.reusables.imports.NamedNode}> {
+    readonly filter?: ObjectFilterT;
+    readonly graph?: Exclude<${this.reusables.imports.Quad_Graph}, ${this.reusables.imports.Variable}>;
+    readonly identifiers?: readonly ObjectIdentifierT[];
+    readonly limit?: number;
+    readonly offset?: number;
+    readonly preferredLanguages?: readonly string[];
+  }
+}`;
+    }
+}
+__decorate([
+    Memoize()
+], ObjectSetType.prototype, "declaration", null);
+//# sourceMappingURL=ObjectSetType.js.map

package/dist/generators/ts/RdfjsDatasetObjectSetType.d.ts

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