@shaclmate/compiler 4.0.9 → 4.0.10

package/dist/generators/ts/{_ObjectType/ObjectType_jsonUiSchemaFunctionDeclaration.js → _NamedObjectType/NamedObjectType_jsonUiSchemaFunctionDeclaration.js}

@@ -1,18 +1,18 @@
 import { Maybe } from "purify-ts";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectType_jsonUiSchemaFunctionDeclaration() {
+export function NamedObjectType_jsonUiSchemaFunctionDeclaration() {
     if (!this.features.has("json")) {
         return Maybe.empty();
     }
     const variables = { scopePrefix: code `scopePrefix` };
     const elements = this.parentObjectTypes
-        .map((parentObjectType) => code `${parentObjectType.staticModuleName}.${syntheticNamePrefix}jsonUiSchema({ scopePrefix })`)
+        .map((parentObjectType) => code `${parentObjectType.staticModuleName}.${syntheticNamePrefix}Json.uiSchema({ scopePrefix })`)
         .concat(this.ownProperties.flatMap((property) => property.jsonUiSchemaElement({ variables }).toList()));
     return Maybe.of(code `\
-export function ${syntheticNamePrefix}jsonUiSchema(parameters?: { scopePrefix?: string }): any {
+export function uiSchema(parameters?: { scopePrefix?: string }): any {
   const scopePrefix = parameters?.scopePrefix ?? "#";
   return { "elements": [ ${joinCode(elements, { on: "," })} ], label: "${this.label.orDefault(this.name)}", type: "Group" };
 }`);
 }
-//# sourceMappingURL=ObjectType_jsonUiSchemaFunctionDeclaration.js.map
+//# sourceMappingURL=NamedObjectType_jsonUiSchemaFunctionDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_objectSetMethodNames.d.ts

@@ -0,0 +1,9 @@
+export declare function NamedObjectType_objectSetMethodNames(this: {
+    readonly name: string;
+}): {
+    object: string;
+    objectCount: string;
+    objectIdentifiers: string;
+    objects: string;
+};
+//# sourceMappingURL=NamedObjectType_objectSetMethodNames.d.ts.map

package/dist/generators/ts/{_ObjectType/ObjectType_objectSetMethodNames.js → _NamedObjectType/NamedObjectType_objectSetMethodNames.js}

@@ -1,6 +1,6 @@
 import { camelCase, trainCase } from "change-case";
 import plur from "plur";
-export function ObjectType_objectSetMethodNames() {
+export function NamedObjectType_objectSetMethodNames() {
     const prefixSingular = camelCase(this.name);
     const thisNameParts = trainCase(this.name).split("-");
     let prefixPlural = camelCase(`${thisNameParts.slice(0, thisNameParts.length - 1).join("")}${plur(thisNameParts[thisNameParts.length - 1])}`);
@@ -15,4 +15,4 @@ export function ObjectType_objectSetMethodNames() {
         objects: prefixPlural,
     };
 }
-//# sourceMappingURL=ObjectType_objectSetMethodNames.js.map
+//# sourceMappingURL=NamedObjectType_objectSetMethodNames.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_propertiesFromJsonFunctionDeclaration.d.ts

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import type { NamedObjectType } from "../NamedObjectType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function NamedObjectType_propertiesFromJsonFunctionDeclaration(this: NamedObjectType): Maybe<Code>;
+//# sourceMappingURL=NamedObjectType_propertiesFromJsonFunctionDeclaration.d.ts.map

package/dist/generators/ts/{_ObjectType/ObjectType_propertiesFromJsonFunctionDeclaration.js → _NamedObjectType/NamedObjectType_propertiesFromJsonFunctionDeclaration.js}

@@ -4,7 +4,7 @@ import { code, joinCode } from "../ts-poet-wrapper.js";
 const variables = {
     jsonObject: code `${syntheticNamePrefix}json`,
 };
-export function ObjectType_propertiesFromJsonFunctionDeclaration() {
+export function NamedObjectType_propertiesFromJsonFunctionDeclaration() {
     if (!this.features.has("json")) {
         return Maybe.empty();
     }
@@ -35,4 +35,4 @@ export function ${syntheticNamePrefix}propertiesFromJson(${variables.jsonObject}
 ${joinCode(statements)}
 }`);
 }
-//# sourceMappingURL=ObjectType_propertiesFromJsonFunctionDeclaration.js.map
+//# sourceMappingURL=NamedObjectType_propertiesFromJsonFunctionDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_propertiesFromRdfResourceFunctionDeclaration.d.ts

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import type { NamedObjectType } from "../NamedObjectType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function NamedObjectType_propertiesFromRdfResourceFunctionDeclaration(this: NamedObjectType): Maybe<Code>;
+//# sourceMappingURL=NamedObjectType_propertiesFromRdfResourceFunctionDeclaration.d.ts.map

package/dist/generators/ts/{_ObjectType/ObjectType_propertiesFromRdfResourceFunctionDeclaration.js → _NamedObjectType/NamedObjectType_propertiesFromRdfResourceFunctionDeclaration.js}

@@ -14,7 +14,7 @@ const variables = {
     preferredLanguages: code `${optionsVariable}.preferredLanguages`,
     resource: code `${syntheticNamePrefix}resource`,
 };
-export function ObjectType_propertiesFromRdfResourceFunctionDeclaration() {
+export function NamedObjectType_propertiesFromRdfResourceFunctionDeclaration() {
     if (!this.features.has("rdf")) {
         return Maybe.empty();
     }
@@ -98,4 +98,4 @@ export const ${syntheticNamePrefix}propertiesFromRdfResource: ${snippets.Propert
 ${joinCode(statements)}
 };`);
 }
-//# sourceMappingURL=ObjectType_propertiesFromRdfResourceFunctionDeclaration.js.map
+//# sourceMappingURL=NamedObjectType_propertiesFromRdfResourceFunctionDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_schemaVariableStatement.d.ts

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

package/dist/generators/ts/{_ObjectType/ObjectType_schemaVariableStatement.js → _NamedObjectType/NamedObjectType_schemaVariableStatement.js}

@@ -1,9 +1,9 @@
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectType_schemaVariableStatement() {
+export function NamedObjectType_schemaVariableStatement() {
     return code `\
 export const ${syntheticNamePrefix}schema = { properties: { ${joinCode(this.parentObjectTypes
         .map((parentObjectType) => code `...${parentObjectType.staticModuleName}.${syntheticNamePrefix}schema.properties`)
         .concat(this.ownProperties.map((property) => code `${property.name}: ${property.schema}`)), { on: ", " })} } } as const;`;
 }
-//# sourceMappingURL=ObjectType_schemaVariableStatement.js.map
+//# sourceMappingURL=NamedObjectType_schemaVariableStatement.js.map

package/dist/generators/ts/{_ObjectType/ObjectType_sparqlConstructQueryFunctionDeclaration.d.ts → _NamedObjectType/NamedObjectType_sparqlConstructQueryFunctionDeclaration.d.ts}

@@ -1,10 +1,10 @@
 import { Maybe } from "purify-ts";
 import type { TsFeature } from "../../../enums/TsFeature.js";
 import { type Code } from "../ts-poet-wrapper.js";
-export declare function ObjectType_sparqlConstructQueryFunctionDeclaration(this: {
+export declare function NamedObjectType_sparqlConstructQueryFunctionDeclaration(this: {
     readonly features: ReadonlySet<TsFeature>;
     readonly filterType: Code;
     readonly name: string;
     readonly staticModuleName: string;
 }): Maybe<Code>;
-//# sourceMappingURL=ObjectType_sparqlConstructQueryFunctionDeclaration.d.ts.map
+//# sourceMappingURL=NamedObjectType_sparqlConstructQueryFunctionDeclaration.d.ts.map

package/dist/generators/ts/{_ObjectType/ObjectType_sparqlConstructQueryFunctionDeclaration.js → _NamedObjectType/NamedObjectType_sparqlConstructQueryFunctionDeclaration.js}

@@ -4,7 +4,7 @@ import { imports } from "../imports.js";
 import { snippets } from "../snippets.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code } from "../ts-poet-wrapper.js";
-export function ObjectType_sparqlConstructQueryFunctionDeclaration() {
+export function NamedObjectType_sparqlConstructQueryFunctionDeclaration() {
     if (!this.features.has("sparql")) {
         return Maybe.empty();
     }
@@ -39,4 +39,4 @@ export function ${syntheticNamePrefix}sparqlConstructQuery({ filter, ignoreRdfTy
   };
 }`);
 }
-//# sourceMappingURL=ObjectType_sparqlConstructQueryFunctionDeclaration.js.map
+//# sourceMappingURL=NamedObjectType_sparqlConstructQueryFunctionDeclaration.js.map

package/dist/generators/ts/{_ObjectType/ObjectType_sparqlConstructQueryStringFunctionDeclaration.d.ts → _NamedObjectType/NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.d.ts}

@@ -1,9 +1,9 @@
 import { Maybe } from "purify-ts";
 import type { TsFeature } from "../../../enums/TsFeature.js";
 import { type Code } from "../ts-poet-wrapper.js";
-export declare function ObjectType_sparqlConstructQueryStringFunctionDeclaration(this: {
+export declare function NamedObjectType_sparqlConstructQueryStringFunctionDeclaration(this: {
     readonly features: ReadonlySet<TsFeature>;
     readonly filterType: Code;
     readonly staticModuleName: string;
 }): Maybe<Code>;
-//# sourceMappingURL=ObjectType_sparqlConstructQueryStringFunctionDeclaration.d.ts.map
+//# sourceMappingURL=NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.d.ts.map

package/dist/generators/ts/{_ObjectType/ObjectType_sparqlConstructQueryStringFunctionDeclaration.js → _NamedObjectType/NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.js}

@@ -2,7 +2,7 @@ import { Maybe } from "purify-ts";
 import { imports } from "../imports.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code } from "../ts-poet-wrapper.js";
-export function ObjectType_sparqlConstructQueryStringFunctionDeclaration() {
+export function NamedObjectType_sparqlConstructQueryStringFunctionDeclaration() {
     if (!this.features.has("sparql")) {
         return Maybe.empty();
     }
@@ -11,4 +11,4 @@ export function ${syntheticNamePrefix}sparqlConstructQueryString(parameters: Par
   return new ${imports.sparqljs}.Generator(parameters).stringify(${this.staticModuleName}.${syntheticNamePrefix}sparqlConstructQuery(parameters));
 }`);
 }
-//# sourceMappingURL=ObjectType_sparqlConstructQueryStringFunctionDeclaration.js.map
+//# sourceMappingURL=NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_toJsonFunctionOrMethodDeclaration.d.ts

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import type { NamedObjectType } from "../NamedObjectType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function NamedObjectType_toJsonFunctionOrMethodDeclaration(this: NamedObjectType): Maybe<Code>;
+//# sourceMappingURL=NamedObjectType_toJsonFunctionOrMethodDeclaration.d.ts.map

package/dist/generators/ts/{_ObjectType/ObjectType_toJsonFunctionOrMethodDeclaration.js → _NamedObjectType/NamedObjectType_toJsonFunctionOrMethodDeclaration.js}

@@ -1,7 +1,7 @@
 import { Maybe } from "purify-ts";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectType_toJsonFunctionOrMethodDeclaration() {
+export function NamedObjectType_toJsonFunctionOrMethodDeclaration() {
     if (!this.features.has("json")) {
         return Maybe.empty();
     }
@@ -56,4 +56,4 @@ ${preamble}${syntheticNamePrefix}toJson(${joinCode(parameters, { on: ", " })}):
   return JSON.parse(JSON.stringify({ ${joinCode(jsonObjectMembers, { on: "," })} } satisfies ${this.jsonType().name}));
 }`);
 }
-//# sourceMappingURL=ObjectType_toJsonFunctionOrMethodDeclaration.js.map
+//# sourceMappingURL=NamedObjectType_toJsonFunctionOrMethodDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_toRdfResourceFunctionOrMethodDeclaration.d.ts

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import type { NamedObjectType } from "../NamedObjectType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function NamedObjectType_toRdfResourceFunctionOrMethodDeclaration(this: NamedObjectType): Maybe<Code>;
+//# sourceMappingURL=NamedObjectType_toRdfResourceFunctionOrMethodDeclaration.d.ts.map

package/dist/generators/ts/{_ObjectType/ObjectType_toRdfResourceFunctionOrMethodDeclaration.js → _NamedObjectType/NamedObjectType_toRdfResourceFunctionOrMethodDeclaration.js}

@@ -5,7 +5,7 @@ import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
 import { snippets } from "../snippets.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectType_toRdfResourceFunctionOrMethodDeclaration() {
+export function NamedObjectType_toRdfResourceFunctionOrMethodDeclaration() {
     if (!this.features.has("rdf")) {
         return Maybe.empty();
     }
@@ -64,4 +64,4 @@ const variables = {
     resource: code `resource`,
     resourceSet: code `resourceSet`,
 };
-//# sourceMappingURL=ObjectType_toRdfResourceFunctionOrMethodDeclaration.js.map
+//# sourceMappingURL=NamedObjectType_toRdfResourceFunctionOrMethodDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration.d.ts

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import type { NamedObjectType } from "../NamedObjectType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration(this: NamedObjectType): Maybe<Code>;
+//# sourceMappingURL=NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration.d.ts.map

package/dist/generators/ts/{_ObjectType/ObjectType_valueSparqlConstructTriplesFunctionDeclaration.js → _NamedObjectType/NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration.js}

@@ -2,7 +2,7 @@ import { Maybe } from "purify-ts";
 import { snippets } from "../snippets.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code } from "../ts-poet-wrapper.js";
-export function ObjectType_valueSparqlConstructTriplesFunctionDeclaration() {
+export function NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration() {
     if (!this.features.has("sparql")) {
         return Maybe.empty();
     }
@@ -10,4 +10,4 @@ export function ObjectType_valueSparqlConstructTriplesFunctionDeclaration() {
 export const ${syntheticNamePrefix}valueSparqlConstructTriples: ${snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}> = ({ filter, ignoreRdfType, valueVariable, variablePrefix }) =>
   ${this.staticModuleName}.${syntheticNamePrefix}focusSparqlConstructTriples({ filter, focusIdentifier: valueVariable, ignoreRdfType, variablePrefix });`);
 }
-//# sourceMappingURL=ObjectType_valueSparqlConstructTriplesFunctionDeclaration.js.map
+//# sourceMappingURL=NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_valueSparqlWherePatternsFunctionDeclaration.d.ts

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import type { NamedObjectType } from "../NamedObjectType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function NamedObjectType_valueSparqlWherePatternsFunctionDeclaration(this: NamedObjectType): Maybe<Code>;
+//# sourceMappingURL=NamedObjectType_valueSparqlWherePatternsFunctionDeclaration.d.ts.map

package/dist/generators/ts/{_ObjectType/ObjectType_valueSparqlWherePatternsFunctionDeclaration.js → _NamedObjectType/NamedObjectType_valueSparqlWherePatternsFunctionDeclaration.js}

@@ -2,7 +2,7 @@ import { Maybe } from "purify-ts";
 import { snippets } from "../snippets.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code } from "../ts-poet-wrapper.js";
-export function ObjectType_valueSparqlWherePatternsFunctionDeclaration() {
+export function NamedObjectType_valueSparqlWherePatternsFunctionDeclaration() {
     if (!this.features.has("sparql")) {
         return Maybe.empty();
     }
@@ -12,4 +12,4 @@ export const ${syntheticNamePrefix}valueSparqlWherePatterns: ${snippets.ValueSpa
     ${this.staticModuleName}.${syntheticNamePrefix}focusSparqlWherePatterns({ filter, focusIdentifier: valueVariable, ignoreRdfType, preferredLanguages, variablePrefix })
   );`);
 }
-//# sourceMappingURL=ObjectType_valueSparqlWherePatternsFunctionDeclaration.js.map
+//# sourceMappingURL=NamedObjectType_valueSparqlWherePatternsFunctionDeclaration.js.map

package/dist/generators/ts/{_ObjectType → _NamedObjectType}/ShaclProperty.d.ts

@@ -29,7 +29,7 @@ export declare class ShaclProperty<TypeT extends Type> extends AbstractProperty<
     get getAccessorDeclaration(): Maybe<Code>;
     get graphqlField(): AbstractProperty<TypeT>["graphqlField"];
     get jsonSignature(): Maybe<Code>;
-    get jsonZodSchema(): AbstractProperty<TypeT>["jsonZodSchema"];
+    get jsonZchema(): AbstractProperty<TypeT>["jsonZchema"];
     protected get schemaObject(): {
         path: Code | undefined;
         kind: Code;

package/dist/generators/ts/{_ObjectType → _NamedObjectType}/ShaclProperty.js

@@ -59,7 +59,7 @@ export class ShaclProperty extends AbstractProperty {
     }
     get declaration() {
         const lhs = [];
-        if (this.objectType.declarationType === "class" &&
+        if (this.namedObjectType.declarationType === "class" &&
             this.visibility !== "public") {
             lhs.push(code `${this.visibility}`);
         }
@@ -103,8 +103,8 @@ export class ShaclProperty extends AbstractProperty {
         const typeJsonType = this.type.jsonType();
         return Maybe.of(code `readonly ${this.name}${typeJsonType.optional ? "?" : ""}: ${typeJsonType.requiredName}`);
     }
-    get jsonZodSchema() {
-        let schema = this.type.jsonZodSchema({
+    get jsonZchema() {
+        let schema = this.type.jsonSchema({
             context: "property",
         });
         this.comment.alt(this.description).ifJust((description) => {
@@ -120,7 +120,7 @@ export class ShaclProperty extends AbstractProperty {
             ...super.schemaObject,
             // comment: this.comment.map(JSON.stringify).extract(),
             // description: this.description.map(JSON.stringify).extract(),
-            path: this.objectType.features.has("rdf")
+            path: this.namedObjectType.features.has("rdf")
                 ? propertyPathToCode(this.path)
                 : undefined,
             // label: this.label.map(JSON.stringify).extract(),
@@ -135,7 +135,7 @@ export class ShaclProperty extends AbstractProperty {
     constructorStatements({ variables, }) {
         const typeConversions = this.type.conversions;
         if (typeConversions.length === 1) {
-            switch (this.objectType.declarationType) {
+            switch (this.namedObjectType.declarationType) {
                 case "class":
                     return [code `this.${this.name} = ${variables.parameter};`];
                 case "interface":
@@ -144,7 +144,7 @@ export class ShaclProperty extends AbstractProperty {
         }
         let lhs;
         const statements = [];
-        switch (this.objectType.declarationType) {
+        switch (this.namedObjectType.declarationType) {
             case "class":
                 lhs = `this.${this.name}`;
                 break;
@@ -176,7 +176,7 @@ export class ShaclProperty extends AbstractProperty {
                 variables: {
                     ...variables,
                     ignoreRdfType: true,
-                    propertyPath: code `${this.objectType.staticModuleName}.${syntheticNamePrefix}schema.properties.${this.name}.path`,
+                    propertyPath: code `${this.namedObjectType.staticModuleName}.${syntheticNamePrefix}schema.properties.${this.name}.path`,
                     resourceValues: code `resourceValues`,
                 },
             })})`,
@@ -263,5 +263,5 @@ __decorate([
 ], ShaclProperty.prototype, "jsonSignature", null);
 __decorate([
     Memoize()
-], ShaclProperty.prototype, "jsonZodSchema", null);
+], ShaclProperty.prototype, "jsonZchema", null);
 //# sourceMappingURL=ShaclProperty.js.map

package/dist/generators/ts/_NamedObjectType/identifierTypeDeclarations.d.ts

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

package/dist/generators/ts/graphqlSchemaVariableStatement.d.ts

@@ -1,9 +1,9 @@
 import { Maybe } from "purify-ts";
+import type { NamedObjectType } from "./NamedObjectType.js";
 import type { NamedObjectUnionType } from "./NamedObjectUnionType.js";
-import type { ObjectType } from "./ObjectType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare function graphqlSchemaVariableStatement(parameters: {
-    objectTypes: readonly ObjectType[];
+    namedObjectTypes: readonly NamedObjectType[];
     namedObjectUnionTypes: NamedObjectUnionType[];
 }): Maybe<Code>;
 //# sourceMappingURL=graphqlSchemaVariableStatement.d.ts.map

package/dist/generators/ts/graphqlSchemaVariableStatement.js

@@ -2,25 +2,25 @@ import { Maybe } from "purify-ts";
 import { imports } from "./imports.js";
 import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code } from "./ts-poet-wrapper.js";
-function graphqlQueryObjectType({ objectTypes, namedObjectUnionTypes, }) {
+function graphqlQueryObjectType({ namedObjectTypes, namedObjectUnionTypes, }) {
     return code `new ${imports.GraphQLObjectType}<null, { objectSet: ${syntheticNamePrefix}ObjectSet }>({ name: "Query", fields: ${[
-        ...objectTypes,
+        ...namedObjectTypes,
         ...namedObjectUnionTypes,
-    ].reduce((fields, objectType) => {
-        fields[objectType.objectSetMethodNames.object] = {
+    ].reduce((fields, namedObjectType) => {
+        fields[namedObjectType.objectSetMethodNames.object] = {
             args: {
                 identifier: {
                     type: code `new ${imports.GraphQLNonNull}(${imports.GraphQLID})`,
                 },
             },
             resolve: code `\
-async (_source, args: { identifier: string }, { objectSet }): Promise<${objectType.name}> => 
-  (await ${imports.EitherAsync}<Error, ${objectType.name}>(async ({ liftEither }) => 
-    liftEither(await objectSet.${objectType.objectSetMethodNames.object}(await liftEither(${objectType.identifierTypeAlias}.fromString(args.identifier))))
+async (_source, args: { identifier: string }, { objectSet }): Promise<${namedObjectType.name}> => 
+  (await ${imports.EitherAsync}<Error, ${namedObjectType.name}>(async ({ liftEither }) => 
+    liftEither(await objectSet.${namedObjectType.objectSetMethodNames.object}(await liftEither(${namedObjectType.identifierTypeAlias}.fromString(args.identifier))))
   )).unsafeCoerce()`,
-            type: objectType.graphqlType.name,
+            type: namedObjectType.graphqlType.name,
         };
-        fields[objectType.objectSetMethodNames.objectIdentifiers] = {
+        fields[namedObjectType.objectSetMethodNames.objectIdentifiers] = {
             args: {
                 limit: {
                     type: code `${imports.GraphQLInt}`,
@@ -31,10 +31,10 @@ async (_source, args: { identifier: string }, { objectSet }): Promise<${objectTy
             },
             resolve: code `\
  async (_source, args: { limit: number | null; offset: number | null; }, { objectSet }): Promise<readonly string[]> =>
-  (await objectSet.${objectType.objectSetMethodNames.objectIdentifiers}({ limit: args.limit !== null ? args.limit : undefined, offset: args.offset !== null ? args.offset : undefined })).unsafeCoerce().map(${objectType.identifierTypeAlias}.toString)`,
+  (await objectSet.${namedObjectType.objectSetMethodNames.objectIdentifiers}({ limit: args.limit !== null ? args.limit : undefined, offset: args.offset !== null ? args.offset : undefined })).unsafeCoerce().map(${namedObjectType.identifierTypeAlias}.toString)`,
             type: code `new ${imports.GraphQLNonNull}(new ${imports.GraphQLList}(${imports.GraphQLString}))`,
         };
-        fields[objectType.objectSetMethodNames.objects] = {
+        fields[namedObjectType.objectSetMethodNames.objects] = {
             args: {
                 identifiers: {
                     type: code `new ${imports.GraphQLList}(new ${imports.GraphQLNonNull}(${imports.GraphQLID}))`,
@@ -47,36 +47,36 @@ async (_source, args: { identifier: string }, { objectSet }): Promise<${objectTy
                 },
             },
             resolve: code `\
-async (_source, args: { identifiers: readonly string[] | null; limit: number | null; offset: number | null; }, { objectSet }): Promise<readonly ${objectType.name}[]> =>
-(await ${imports.EitherAsync}<Error, readonly ${objectType.name}[]>(async ({ liftEither }) => {
-  let filter: ${objectType.filterType} | undefined;
+async (_source, args: { identifiers: readonly string[] | null; limit: number | null; offset: number | null; }, { objectSet }): Promise<readonly ${namedObjectType.name}[]> =>
+(await ${imports.EitherAsync}<Error, readonly ${namedObjectType.name}[]>(async ({ liftEither }) => {
+  let filter: ${namedObjectType.filterType} | undefined;
   if (args.identifiers) {
-    const identifiers: ${objectType.identifierTypeAlias}[] = [];
+    const identifiers: ${namedObjectType.identifierTypeAlias}[] = [];
     for (const identifierArg of args.identifiers) {
-      identifiers.push(await liftEither(${objectType.identifierTypeAlias}.fromString(identifierArg)));
+      identifiers.push(await liftEither(${namedObjectType.identifierTypeAlias}.fromString(identifierArg)));
     }
     filter = { ${syntheticNamePrefix}identifier: { in: identifiers } };
   }
-  return await liftEither(await objectSet.${objectType.objectSetMethodNames.objects}({ filter, limit: args.limit !== null ? args.limit : undefined, offset: args.offset !== null ? args.offset : undefined }));
+  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 ${imports.GraphQLNonNull}(new ${imports.GraphQLList}(${objectType.graphqlType.name}))`,
+            type: code `new ${imports.GraphQLNonNull}(new ${imports.GraphQLList}(${namedObjectType.graphqlType.name}))`,
         };
-        fields[objectType.objectSetMethodNames.objectCount] = {
+        fields[namedObjectType.objectSetMethodNames.objectCount] = {
             resolve: code `\
-async (_source, _args, { objectSet }): Promise<number> => (await objectSet.${objectType.objectSetMethodNames.objectCount}()).unsafeCoerce()`,
+async (_source, _args, { objectSet }): Promise<number> => (await objectSet.${namedObjectType.objectSetMethodNames.objectCount}()).unsafeCoerce()`,
             type: code `new ${imports.GraphQLNonNull}(${imports.GraphQLInt})`,
         };
         return fields;
     }, {})} })`;
 }
 export function graphqlSchemaVariableStatement(parameters) {
-    const objectTypes = parameters.objectTypes.filter((objectType) => objectType.features.has("graphql") && !objectType.synthetic);
+    const namedObjectTypes = parameters.namedObjectTypes.filter((namedObjectType) => namedObjectType.features.has("graphql") && !namedObjectType.synthetic);
     const namedObjectUnionTypes = parameters.namedObjectUnionTypes.filter((namedObjectUnionType) => namedObjectUnionType.features.has("graphql"));
-    if (objectTypes.length === 0) {
+    if (namedObjectTypes.length === 0) {
         return Maybe.empty();
     }
     return Maybe.of(code `\
-export const graphqlSchema = new ${imports.GraphQLSchema}({ query: ${graphqlQueryObjectType({ objectTypes, namedObjectUnionTypes })} });
+export const graphqlSchema = new ${imports.GraphQLSchema}({ query: ${graphqlQueryObjectType({ namedObjectTypes: namedObjectTypes, namedObjectUnionTypes })} });
 `);
 }
 //# sourceMappingURL=graphqlSchemaVariableStatement.js.map

package/dist/generators/ts/objectSetDeclarations.d.ts

@@ -1,8 +1,8 @@
+import type { NamedObjectType } from "./NamedObjectType.js";
 import type { NamedObjectUnionType } from "./NamedObjectUnionType.js";
-import type { ObjectType } from "./ObjectType.js";
 import type { Code } from "./ts-poet-wrapper.js";
 export declare function objectSetDeclarations({ namedObjectUnionTypes, ...parameters }: {
-    objectTypes: readonly ObjectType[];
+    namedObjectTypes: readonly NamedObjectType[];
     namedObjectUnionTypes: readonly NamedObjectUnionType[];
 }): readonly Code[];
 //# sourceMappingURL=objectSetDeclarations.d.ts.map

package/dist/generators/ts/objectSetDeclarations.js

@@ -2,18 +2,21 @@ import { objectSetInterfaceDeclaration } from "./objectSetInterfaceDeclaration.j
 import { rdfjsDatasetObjectSetClassDeclaration } from "./rdfjsDatasetObjectSetClassDeclaration.js";
 import { sparqlObjectSetClassDeclaration } from "./sparqlObjectSetClassDeclaration.js";
 export function objectSetDeclarations({ namedObjectUnionTypes, ...parameters }) {
-    const objectTypes = parameters.objectTypes.filter((objectType) => !objectType.abstract && !objectType.extern && !objectType.synthetic);
-    let objectTypesWithRdfFeatureCount = 0;
-    let objectTypesWithSparqlFeatureCount = 0;
-    for (const objectType of objectTypes) {
-        if (!objectType.features.has("rdf") && !objectType.features.has("sparql")) {
+    const namedObjectTypes = parameters.namedObjectTypes.filter((namedObjectType) => !namedObjectType.abstract &&
+        !namedObjectType.extern &&
+        !namedObjectType.synthetic);
+    let namedObjectTypesWithRdfFeatureCount = 0;
+    let namedObjectTypesWithSparqlFeatureCount = 0;
+    for (const namedObjectType of namedObjectTypes) {
+        if (!namedObjectType.features.has("rdf") &&
+            !namedObjectType.features.has("sparql")) {
             continue;
         }
-        if (objectType.features.has("rdf")) {
-            objectTypesWithRdfFeatureCount++;
+        if (namedObjectType.features.has("rdf")) {
+            namedObjectTypesWithRdfFeatureCount++;
         }
-        if (objectType.features.has("sparql")) {
-            objectTypesWithSparqlFeatureCount++;
+        if (namedObjectType.features.has("sparql")) {
+            namedObjectTypesWithSparqlFeatureCount++;
         }
     }
     let namedObjectUnionTypesWithRdfFeatureCount = 0;
@@ -30,27 +33,27 @@ export function objectSetDeclarations({ namedObjectUnionTypes, ...parameters })
             namedObjectUnionTypesWithSparqlFeatureCount++;
         }
     }
-    if (objectTypesWithRdfFeatureCount === 0 &&
-        objectTypesWithSparqlFeatureCount === 0 &&
+    if (namedObjectTypesWithRdfFeatureCount === 0 &&
+        namedObjectTypesWithSparqlFeatureCount === 0 &&
         namedObjectUnionTypesWithRdfFeatureCount === 0 &&
         namedObjectUnionTypesWithSparqlFeatureCount === 0) {
         return [];
     }
     const declarations = [
         objectSetInterfaceDeclaration({
-            objectTypes,
+            namedObjectTypes: namedObjectTypes,
             namedObjectUnionTypes,
         }),
     ];
-    if (objectTypesWithRdfFeatureCount > 0) {
+    if (namedObjectTypesWithRdfFeatureCount > 0) {
         declarations.push(rdfjsDatasetObjectSetClassDeclaration({
-            objectTypes,
+            namedObjectTypes: namedObjectTypes,
             namedObjectUnionTypes,
         }));
     }
-    if (objectTypesWithSparqlFeatureCount > 0) {
+    if (namedObjectTypesWithSparqlFeatureCount > 0) {
         declarations.push(sparqlObjectSetClassDeclaration({
-            objectTypes,
+            namedObjectTypes: namedObjectTypes,
             namedObjectUnionTypes,
         }));
     }

package/dist/generators/ts/objectSetInterfaceDeclaration.d.ts

@@ -1,8 +1,8 @@
+import type { NamedObjectType } from "./NamedObjectType.js";
 import type { NamedObjectUnionType } from "./NamedObjectUnionType.js";
-import type { ObjectType } from "./ObjectType.js";
 import { type Code } from "./ts-poet-wrapper.js";
-export declare function objectSetInterfaceDeclaration({ objectTypes, namedObjectUnionTypes, }: {
-    objectTypes: readonly ObjectType[];
+export declare function objectSetInterfaceDeclaration({ namedObjectTypes, namedObjectUnionTypes, }: {
+    namedObjectTypes: readonly NamedObjectType[];
     namedObjectUnionTypes: readonly NamedObjectUnionType[];
 }): Code;
 //# sourceMappingURL=objectSetInterfaceDeclaration.d.ts.map

package/dist/generators/ts/objectSetInterfaceDeclaration.js

@@ -2,12 +2,14 @@ import { imports } from "./imports.js";
 import { objectSetMethodSignatures } from "./objectSetMethodSignatures.js";
 import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
-export function objectSetInterfaceDeclaration({ objectTypes, namedObjectUnionTypes, }) {
+export function objectSetInterfaceDeclaration({ namedObjectTypes, namedObjectUnionTypes, }) {
     return code `\
 export interface ${syntheticNamePrefix}ObjectSet {
-  ${joinCode(objectTypes
-        .flatMap((objectType) => Object.values(objectSetMethodSignatures({ objectType })))
-        .concat(namedObjectUnionTypes.flatMap((namedObjectUnionType) => Object.values(objectSetMethodSignatures({ objectType: namedObjectUnionType }))))
+  ${joinCode(namedObjectTypes
+        .flatMap((namedObjectType) => Object.values(objectSetMethodSignatures({ namedObjectType })))
+        .concat(namedObjectUnionTypes.flatMap((namedObjectUnionType) => Object.values(objectSetMethodSignatures({
+        namedObjectType: namedObjectUnionType,
+    }))))
         .map((methodSignature) => code `${methodSignature.name}(${methodSignature.parameters}): ${methodSignature.returnType};`), { on: "\n\n" })}
 }
 

package/dist/generators/ts/objectSetMethodSignatures.d.ts

@@ -1,15 +1,15 @@
-import type { ObjectType } from "./ObjectType.js";
+import type { NamedObjectType } from "./NamedObjectType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare function objectSetMethodSignatures(parameters: {
-    objectType: {
+    namedObjectType: {
         readonly filterType: Code;
         readonly identifierTypeAlias: Code;
-        readonly objectSetMethodNames: ObjectType.ObjectSetMethodNames;
+        readonly objectSetMethodNames: NamedObjectType.ObjectSetMethodNames;
         readonly name: string;
     };
     parameterNamePrefix?: string;
     queryT?: string;
-}): Readonly<Record<keyof ObjectType.ObjectSetMethodNames, {
+}): Readonly<Record<keyof NamedObjectType.ObjectSetMethodNames, {
     readonly name: string;
     readonly parameters: Code;
     readonly returnType: Code;