@shaclmate/compiler 4.0.28 → 4.0.30

package/dist/generators/ts/rdfjsTermExpression.js

@@ -1,19 +1,17 @@
 import { rdf, rdfs, xsd } from "@tpluscode/rdf-ns-builders";
-import { snippets_RdfVocabularies } from "./_snippets/snippets_RdfVocabularies.js";
-import { imports } from "./imports.js";
 import { code, literalOf } from "./ts-poet-wrapper.js";
-export function rdfjsTermExpression(rdfjsTerm, { logger }) {
+export function rdfjsTermExpression(rdfjsTerm) {
     switch (rdfjsTerm.termType) {
         case "BlankNode":
-            return code `${imports.dataFactory}.blankNode(${literalOf(rdfjsTerm.value)})`;
+            return code `${this.imports.dataFactory}.blankNode(${literalOf(rdfjsTerm.value)})`;
         case "Literal":
             if (rdfjsTerm.datatype.equals(xsd.string)) {
                 if (rdfjsTerm.language.length === 0) {
-                    return code `${imports.dataFactory}.literal(${literalOf(rdfjsTerm.value)})`;
+                    return code `${this.imports.dataFactory}.literal(${literalOf(rdfjsTerm.value)})`;
                 }
-                return code `${imports.dataFactory}.literal(${literalOf(rdfjsTerm.value)}, ${literalOf(rdfjsTerm.language)})`;
+                return code `${this.imports.dataFactory}.literal(${literalOf(rdfjsTerm.value)}, ${literalOf(rdfjsTerm.language)})`;
             }
-            return code `${imports.dataFactory}.literal(${literalOf(rdfjsTerm.value)}, ${rdfjsTermExpression(rdfjsTerm.datatype, { logger })})`;
+            return code `${this.imports.dataFactory}.literal(${literalOf(rdfjsTerm.value)}, ${rdfjsTermExpression.call(this, rdfjsTerm.datatype)})`;
         case "NamedNode": {
             if (rdfjsTerm.value.startsWith(rdf[""].value)) {
                 const unqualifiedName = rdfjsTerm.value.substring(rdf[""].value.length);
@@ -23,18 +21,18 @@ export function rdfjsTermExpression(rdfjsTerm, { logger }) {
                     case "rest":
                     case "subject":
                     case "type":
-                        return code `${snippets_RdfVocabularies}.rdf.${unqualifiedName}`;
+                        return code `${this.snippets.RdfVocabularies}.rdf.${unqualifiedName}`;
                     default:
-                        logger.warn("unrecognized rdf IRI: %s", rdfjsTerm.value);
+                        this.logger.warn("unrecognized rdf IRI: %s", rdfjsTerm.value);
                 }
             }
             else if (rdfjsTerm.value.startsWith(rdfs[""].value)) {
                 const unqualifiedName = rdfjsTerm.value.substring(rdfs[""].value.length);
                 switch (unqualifiedName) {
                     case "subClassOf":
-                        return code `${snippets_RdfVocabularies}.rdfs.${unqualifiedName}`;
+                        return code `${this.snippets.RdfVocabularies}.rdfs.${unqualifiedName}`;
                     default:
-                        logger.warn("unrecognized rdfs IRI: %s", rdfjsTerm.value);
+                        this.logger.warn("unrecognized rdfs IRI: %s", rdfjsTerm.value);
                 }
             }
             else if (rdfjsTerm.value.startsWith(xsd[""].value)) {
@@ -60,15 +58,15 @@ export function rdfjsTermExpression(rdfjsTerm, { logger }) {
                     case "unsignedInt":
                     case "unsignedLong":
                     case "unsignedShort":
-                        return code `${snippets_RdfVocabularies}.xsd.${unqualifiedName}`;
+                        return code `${this.snippets.RdfVocabularies}.xsd.${unqualifiedName}`;
                     default:
-                        logger.warn("unrecognized xsd IRI: %s", rdfjsTerm.value);
+                        this.logger.warn("unrecognized xsd IRI: %s", rdfjsTerm.value);
                 }
             }
-            return code `${imports.dataFactory}.namedNode(${literalOf(rdfjsTerm.value)})`;
+            return code `${this.imports.dataFactory}.namedNode(${literalOf(rdfjsTerm.value)})`;
         }
         case "Variable":
-            return code `${imports.dataFactory}.variable!(${literalOf(rdfjsTerm.value)})`;
+            return code `${this.imports.dataFactory}.variable!(${literalOf(rdfjsTerm.value)})`;
     }
 }
 //# sourceMappingURL=rdfjsTermExpression.js.map

package/dist/generators/ts/sparqlObjectSetClassDeclaration.d.ts

@@ -1,7 +1,8 @@
 import type { NamedObjectType } from "./NamedObjectType.js";
 import type { NamedObjectUnionType } from "./NamedObjectUnionType.js";
+import type { TsGenerator } from "./TsGenerator.js";
 import { type Code } from "./ts-poet-wrapper.js";
-export declare function sparqlObjectSetClassDeclaration({ namedObjectTypes, namedObjectUnionTypes, }: {
+export declare function sparqlObjectSetClassDeclaration(this: TsGenerator, { namedObjectTypes, namedObjectUnionTypes, }: {
     namedObjectTypes: readonly NamedObjectType[];
     namedObjectUnionTypes: readonly NamedObjectUnionType[];
 }): Code;

package/dist/generators/ts/sparqlObjectSetClassDeclaration.js

@@ -1,45 +1,43 @@
-import { imports } from "./imports.js";
 import { objectSetMethodSignatures } from "./objectSetMethodSignatures.js";
-import { snippets } from "./snippets.js";
 import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 import { unsupportedObjectSetMethodDeclarations } from "./unsupportedObjectSetMethodDeclarations.js";
 export function sparqlObjectSetClassDeclaration({ namedObjectTypes, namedObjectUnionTypes, }) {
     const parameters = {
         constructObjectType: code `namedObjectType: {\
-  ${syntheticNamePrefix}focusSparqlWherePatterns: ${snippets.FocusSparqlWherePatternsFunction}<ObjectFilterT>;
-  ${syntheticNamePrefix}fromRdfResource:  ${snippets.FromRdfResourceFunction}<ObjectT>;
-  ${syntheticNamePrefix}sparqlConstructQueryString: (parameters: { filter?: ObjectFilterT; subject: ${imports.NamedNode} | ${imports.Variable}; } & Omit<${imports.sparqljs}.ConstructQuery, "prefixes" | "queryType" | "type"> & ${imports.sparqljs}.GeneratorOptions) => string;
+  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: { ${syntheticNamePrefix}focusSparqlWherePatterns: ${snippets.FocusSparqlWherePatternsFunction}<ObjectFilterT> }`,
+        selectObjectTypeType: code `namedObjectType: { focusSparqlWherePatterns: ${this.reusables.snippets.FocusSparqlWherePatternsFunction}<ObjectFilterT> }`,
     };
-    const sparqlClientType = code `{ queryBindings: (query: string) => Promise<readonly Record<string, ${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode}>[]>; queryQuads: (query: string) => Promise<readonly ${imports.Quad}[]>; }`;
+    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 ${imports.BlankNode} | ${imports.NamedNode}`,
+        ObjectIdentifierT: code `ObjectIdentifierT extends ${this.reusables.imports.BlankNode} | ${this.reusables.imports.NamedNode}`,
     };
     return code `\
 export class ${syntheticNamePrefix}SparqlObjectSet implements ${syntheticNamePrefix}ObjectSet {
-  readonly #countVariable = ${imports.dataFactory}.variable!("count");;
-  readonly #graph?: Exclude<${imports.Quad_Graph}, ${imports.Variable}>;
-  readonly #objectVariable = ${imports.dataFactory}.variable!("object");
+  readonly #countVariable = ${this.reusables.imports.dataFactory}.variable!("count");;
+  readonly #graph?: Exclude<${this.reusables.imports.Quad_Graph}, ${this.reusables.imports.Variable}>;
+  readonly #objectVariable = ${this.reusables.imports.dataFactory}.variable!("object");
   readonly #sparqlClient: ${sparqlClientType};
-  readonly #sparqlGenerator = new ${imports.sparqljs}.Generator();
+  readonly #sparqlGenerator = new ${this.reusables.imports.sparqljs}.Generator();
 
-  constructor(sparqlClient: ${sparqlClientType}, options?: { graph?: Exclude<${imports.Quad_Graph}, ${imports.Variable}> }) {
+  constructor(sparqlClient: ${sparqlClientType}, options?: { graph?: Exclude<${this.reusables.imports.Quad_Graph}, ${this.reusables.imports.Variable}> }) {
     this.#graph = options?.graph;
     this.#sparqlClient = sparqlClient;
   }
 
 ${joinCode([...namedObjectTypes, ...namedObjectUnionTypes].flatMap((namedObjectType) => {
         if (!namedObjectType.features.has("sparql")) {
-            return Object.values(unsupportedObjectSetMethodDeclarations({
+            return Object.values(unsupportedObjectSetMethodDeclarations.call(this, {
                 namedObjectType,
             }));
         }
-        const methodSignatures = objectSetMethodSignatures({
+        const methodSignatures = objectSetMethodSignatures.call(this, {
             namedObjectType,
             queryT: `${syntheticNamePrefix}SparqlObjectSet.Query`,
         });
@@ -64,29 +62,29 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
         ];
     }), { on: "\n\n" })}
 
-  #mapBindingsToCount(bindings: readonly Record<string, ${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode}>[], variable: string): ${imports.Either}<Error, number> {
+  #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) {
-      return ${imports.Left}(new Error("empty result rows"));
+      return ${this.reusables.imports.Left}(new Error("empty result rows"));
     }
     if (bindings.length > 1) {
-      return ${imports.Left}(new Error("more than one result row"));
+      return ${this.reusables.imports.Left}(new Error("more than one result row"));
     }
     const count = bindings[0][variable];
     if (count === undefined) {
-      return ${imports.Left}(new Error("no 'count' variable in result row"));
+      return ${this.reusables.imports.Left}(new Error("no 'count' variable in result row"));
     }
     if (count.termType !== "Literal") {
-      return ${imports.Left}(new Error("'count' variable is not a Literal"));
+      return ${this.reusables.imports.Left}(new Error("'count' variable is not a Literal"));
     }
     const parsedCount = Number.parseInt(count.value, 10);
     if (Number.isNaN(parsedCount)) {
-      return ${imports.Left}(new Error("'count' variable is NaN"));
+      return ${this.reusables.imports.Left}(new Error("'count' variable is NaN"));
     }
-    return ${imports.Right}(parsedCount);
+    return ${this.reusables.imports.Right}(parsedCount);
   }
 
-  #mapBindingsToIdentifiers(bindings: readonly Record<string, ${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode}>[], variable: string): readonly ${imports.NamedNode}[] {
-    const identifiers: ${imports.NamedNode}[] = [];
+  #mapBindingsToIdentifiers(bindings: readonly Record<string, ${this.reusables.imports.BlankNode} | ${this.reusables.imports.Literal} | ${this.reusables.imports.NamedNode}>[], variable: string): readonly ${this.reusables.imports.NamedNode}[] {
+    const identifiers: ${this.reusables.imports.NamedNode}[] = [];
     for (const bindings_ of bindings) {
       const identifier = bindings_[variable];
       if (
@@ -99,14 +97,14 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
     return identifiers;
   }
 
-  async #objectIdentifiers<${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(${parameters.selectObjectTypeType}, ${parameters.query}): Promise<${imports.Either}<Error, readonly ObjectIdentifierT[]>> {
+  async #objectIdentifiers<${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(${parameters.selectObjectTypeType}, ${parameters.query}): Promise<${this.reusables.imports.Either}<Error, readonly ObjectIdentifierT[]>> {
     if (query?.identifiers) {
-      return ${imports.Right}(query.identifiers);
+      return ${this.reusables.imports.Right}(query.identifiers);
     }
 
     const limit = query?.limit ?? Number.MAX_SAFE_INTEGER;
     if (limit <= 0) {
-      return ${imports.Right}([]);
+      return ${this.reusables.imports.Right}([]);
     }
 
     let offset = query?.offset ?? 0;
@@ -116,7 +114,7 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
 
     const wherePatterns = this.#wherePatterns(namedObjectType, query);
     if (wherePatterns.length === 0) {
-      return ${imports.Left}(new Error("no SPARQL WHERE patterns for identifiers"));
+      return ${this.reusables.imports.Left}(new Error("no SPARQL WHERE patterns for identifiers"));
     }
 
     const selectQueryString = \
@@ -132,7 +130,7 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
         where: wherePatterns.concat()
       });
       
-    return ${imports.EitherAsync}(async () =>
+    return ${this.reusables.imports.EitherAsync}(async () =>
       this.#mapBindingsToIdentifiers(
         await this.#sparqlClient.queryBindings(selectQueryString),
         this.#objectVariable.value,
@@ -140,20 +138,20 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
     );  
   }
 
-  async #objects<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(${parameters.constructObjectType}, ${parameters.query}): Promise<${imports.Either}<Error, readonly ObjectT[]>> {
-    return ${imports.EitherAsync}(async ({ liftEither }) => {
+  async #objects<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(${parameters.constructObjectType}, ${parameters.query}): Promise<${this.reusables.imports.Either}<Error, readonly ObjectT[]>> {
+    return ${this.reusables.imports.EitherAsync}(async ({ liftEither }) => {
       const identifiers = await liftEither(await this.#objectIdentifiers<ObjectFilterT, ObjectIdentifierT>(namedObjectType, query));
       if (identifiers.length === 0) {
         return [];
       }
 
-      const constructQueryString = namedObjectType.${syntheticNamePrefix}sparqlConstructQueryString({
+      const constructQueryString = namedObjectType.sparqlConstructQueryString({
         subject: this.#objectVariable,
         where: [{
           type: "values" as const,
           values: identifiers.map((identifier) => {
-            const valuePatternRow: ${imports.sparqljs}.ValuePatternRow = {};
-            valuePatternRow["?object"] = identifier as ${imports.NamedNode};
+            const valuePatternRow: ${this.reusables.imports.sparqljs}.ValuePatternRow = {};
+            valuePatternRow["?object"] = identifier as ${this.reusables.imports.NamedNode};
             return valuePatternRow;
           }),
         }]
@@ -161,19 +159,19 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
 
       const quads = await this.#sparqlClient.queryQuads(constructQueryString);
 
-      const dataset = ${imports.datasetFactory}.dataset(quads.concat());
+      const dataset = ${this.reusables.imports.datasetFactory}.dataset(quads.concat());
       const objects: ObjectT[] = [];
       for (const identifier of identifiers) {
-        objects.push(await liftEither(namedObjectType.${syntheticNamePrefix}fromRdfResource(new ${imports.Resource}({ dataFactory: ${imports.dataFactory}, dataset: dataset, identifier: identifier as ${imports.NamedNode} }), { objectSet: this, preferredLanguages: query?.preferredLanguages })));
+        objects.push(await liftEither(namedObjectType.fromRdfResource(new ${this.reusables.imports.Resource}({ dataFactory: ${this.reusables.imports.dataFactory}, dataset: dataset, identifier: identifier as ${this.reusables.imports.NamedNode} }), { objectSet: this, preferredLanguages: query?.preferredLanguages })));
       }
       return objects;
     });
   }
 
-  async #objectCount<${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(${parameters.selectObjectTypeType}, ${parameters.query}): Promise<${imports.Either}<Error, number>> {
+  async #objectCount<${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(${parameters.selectObjectTypeType}, ${parameters.query}): Promise<${this.reusables.imports.Either}<Error, number>> {
     const wherePatterns = this.#wherePatterns(namedObjectType, query);
     if (wherePatterns.length === 0) {
-      return ${imports.Left}(new Error("no SPARQL WHERE patterns for count"));
+      return ${this.reusables.imports.Left}(new Error("no SPARQL WHERE patterns for count"));
     }
 
     const selectQueryString = \
@@ -195,7 +193,7 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
         where: wherePatterns.concat()
       });
 
-    return ${imports.EitherAsync}(async ({ liftEither }) =>
+    return ${this.reusables.imports.EitherAsync}(async ({ liftEither }) =>
       liftEither(
         this.#mapBindingsToCount(
           await this.#sparqlClient.queryBindings(selectQueryString),
@@ -205,17 +203,17 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
     );
   }
 
-  #wherePatterns<${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(${parameters.selectObjectTypeType}, ${parameters.query}): readonly ${imports.sparqljs}.Pattern[] {
+  #wherePatterns<${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(${parameters.selectObjectTypeType}, ${parameters.query}): readonly ${this.reusables.imports.sparqljs}.Pattern[] {
     // Patterns should be most to least specific.
-    let patterns: ${imports.sparqljs}.Pattern[] = [];
+    let patterns: ${this.reusables.imports.sparqljs}.Pattern[] = [];
 
     if (query?.where) {
       patterns = patterns.concat(query.where(this.#objectVariable));
     }
 
-    patterns = patterns.concat(namedObjectType.${syntheticNamePrefix}focusSparqlWherePatterns({ filter: query?.filter, focusIdentifier: this.#objectVariable, ignoreRdfType: false, preferredLanguages: query?.preferredLanguages, variablePrefix: this.#objectVariable.value }));
+    patterns = patterns.concat(namedObjectType.focusSparqlWherePatterns({ filter: query?.filter, focusIdentifier: this.#objectVariable, ignoreRdfType: false, preferredLanguages: query?.preferredLanguages, variablePrefix: this.#objectVariable.value }));
 
-    patterns = ${snippets.normalizeSparqlWherePatterns}(patterns).concat();
+    patterns = ${this.reusables.snippets.normalizeSparqlWherePatterns}(patterns).concat();
 
     const graph = query?.graph ?? this.#graph;
     if (graph) {
@@ -227,12 +225,12 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
       }
     }
     // Union of all graphs: { ... patterns covering default graph ... } UNION { GRAPH ?g { ... patterns covering named graphs ... } }
-    return [{ patterns: [{ patterns, type: "group" }, { name: ${imports.dataFactory}.variable!("g"), patterns, type: "graph" }], type: "union" }];
+    return [{ patterns: [{ patterns, type: "group" }, { name: ${this.reusables.imports.dataFactory}.variable!("g"), patterns, type: "graph" }], type: "union" }];
   }
 }
   
 export namespace ${syntheticNamePrefix}SparqlObjectSet {
-  export type Query<${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}> = ${syntheticNamePrefix}ObjectSet.Query<ObjectFilterT, ObjectIdentifierT> & { readonly order?: (objectVariable: ${imports.Variable}) => readonly ${imports.sparqljs}.Ordering[]; readonly where?: (objectVariable: ${imports.Variable}) => readonly ${imports.sparqljs}.Pattern[] };
+  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

package/dist/generators/ts/unsupportedObjectSetMethodDeclarations.d.ts

@@ -1,6 +1,7 @@
 import type { NamedObjectType } from "./NamedObjectType.js";
+import type { TsGenerator } from "./TsGenerator.js";
 import { type Code } from "./ts-poet-wrapper.js";
-export declare function unsupportedObjectSetMethodDeclarations({ namedObjectType, }: {
+export declare function unsupportedObjectSetMethodDeclarations(this: TsGenerator, { namedObjectType, }: {
     namedObjectType: {
         readonly filterType: Code;
         readonly identifierTypeAlias: Code;

package/dist/generators/ts/unsupportedObjectSetMethodDeclarations.js

@@ -1,22 +1,21 @@
-import { imports } from "./imports.js";
 import { objectSetMethodSignatures } from "./objectSetMethodSignatures.js";
 import { code } from "./ts-poet-wrapper.js";
 function unsupportedObjectSetMethodDeclaration({ name, parameters, returnType, }) {
     return code `\
 async ${name}(${parameters}): ${returnType} {
-  return ${imports.Left}(new Error("${name}: not supported")) satisfies Awaited<${returnType}>;
+  return ${this.reusables.imports.Left}(new Error("${name}: not supported")) satisfies Awaited<${returnType}>;
 }`;
 }
 export function unsupportedObjectSetMethodDeclarations({ namedObjectType, }) {
-    const methodSignatures = objectSetMethodSignatures({
+    const methodSignatures = objectSetMethodSignatures.call(this, {
         namedObjectType,
         parameterNamePrefix: "_",
     });
     return {
-        object: unsupportedObjectSetMethodDeclaration(methodSignatures.object),
-        objectCount: unsupportedObjectSetMethodDeclaration(methodSignatures.objectCount),
-        objectIdentifiers: unsupportedObjectSetMethodDeclaration(methodSignatures.objectIdentifiers),
-        objects: unsupportedObjectSetMethodDeclaration(methodSignatures.objects),
+        object: unsupportedObjectSetMethodDeclaration.call(this, methodSignatures.object),
+        objectCount: unsupportedObjectSetMethodDeclaration.call(this, methodSignatures.objectCount),
+        objectIdentifiers: unsupportedObjectSetMethodDeclaration.call(this, methodSignatures.objectIdentifiers),
+        objects: unsupportedObjectSetMethodDeclaration.call(this, methodSignatures.objects),
     };
 }
 //# sourceMappingURL=unsupportedObjectSetMethodDeclarations.js.map

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export * as ast from "./ast/index.js";
 export * from "./Compiler.js";
 export * from "./generators/index.js";
-export * from "./input/ShapesGraph.js";
+export * from "./input/index.js";
 export * from "./ShapesGraphToAstTransformer.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,6 +1,6 @@
 export * as ast from "./ast/index.js";
 export * from "./Compiler.js";
 export * from "./generators/index.js";
-export * from "./input/ShapesGraph.js";
+export * from "./input/index.js";
 export * from "./ShapesGraphToAstTransformer.js";
 //# sourceMappingURL=index.js.map

package/dist/input/ShapesGraph.d.ts

@@ -38,10 +38,10 @@ export declare namespace ShapesGraph {
             readonly PropertyShape: typeof generated.PropertyShape;
         };
         build(): ShapesGraph;
-        nodeShape(parameters?: Parameters<typeof generated.NodeShape.$create>[0]): generated.NodeShape;
-        ontology(parameters?: Parameters<typeof generated.Ontology.$create>[0]): generated.Ontology;
-        propertyGroup(parameters?: Parameters<typeof generated.PropertyGroup.$create>[0]): generated.PropertyGroup;
-        propertyShape(parameters: Parameters<typeof generated.PropertyShape.$create>[0]): generated.PropertyShape;
+        nodeShape(parameters?: Parameters<typeof generated.NodeShape.create>[0]): generated.NodeShape;
+        ontology(parameters?: Parameters<typeof generated.Ontology.create>[0]): generated.Ontology;
+        propertyGroup(parameters?: Parameters<typeof generated.PropertyGroup.create>[0]): generated.PropertyGroup;
+        propertyShape(parameters: Parameters<typeof generated.PropertyShape.create>[0]): generated.PropertyShape;
     }
 }
 //# sourceMappingURL=ShapesGraph.d.ts.map

package/dist/input/ShapesGraph.js

@@ -42,22 +42,22 @@ export class ShapesGraph extends AbstractShapesGraph {
             });
         }
         nodeShape(parameters) {
-            const nodeShape = generated.NodeShape.$create(parameters);
+            const nodeShape = generated.NodeShape.create(parameters);
             this.add(nodeShape);
             return nodeShape;
         }
         ontology(parameters) {
-            const ontology = generated.Ontology.$create(parameters);
+            const ontology = generated.Ontology.create(parameters);
             this.add(ontology);
             return ontology;
         }
         propertyGroup(parameters) {
-            const propertyGroup = generated.PropertyGroup.$create(parameters);
+            const propertyGroup = generated.PropertyGroup.create(parameters);
             this.add(propertyGroup);
             return propertyGroup;
         }
         propertyShape(parameters) {
-            const propertyShape = generated.PropertyShape.$create(parameters);
+            const propertyShape = generated.PropertyShape.create(parameters);
             this.add(propertyShape);
             return propertyShape;
         }