@shaclmate/compiler 4.0.34 → 4.0.35

package/dist/generators/ts/_NamedObjectType/ShaclProperty.js

@@ -29,9 +29,13 @@ export class ShaclProperty extends AbstractProperty {
         this.recursive = recursive;
     }
     get constructorParameter() {
+        const conversionFunction = this.type.conversionFunction.extract();
+        if (!conversionFunction) {
+            return Maybe.of(code `readonly ${this.name}: ${this.type.name};`);
+        }
         let hasQuestionToken = false;
         const typeNames = [];
-        for (const type of this.type.conversionFunction.sourceTypes) {
+        for (const type of conversionFunction.sourceTypes) {
             if (type.typeof === "undefined") {
                 hasQuestionToken = true;
             }
@@ -111,7 +115,23 @@ export class ShaclProperty extends AbstractProperty {
         };
     }
     constructorInitializer({ variables, }) {
-        return Maybe.of(code `${this.name}: ${this.type.conversionFunction.code}(schema.properties.${this.name}.type(), ${variables.parameters}.${this.name})`);
+        const parameterVariable = code `${variables.parameters}.${this.name}`;
+        const conversionFunction = this.type.conversionFunction.extract()?.code;
+        const validationFunction = this.type.validationFunction.extract();
+        let rhs;
+        if (conversionFunction && validationFunction) {
+            rhs = code `${conversionFunction}(${parameterVariable}).chain(value => ${validationFunction}(${this.namedObjectType.name}.schema.properties.${this.name}.type(), value))`;
+        }
+        else if (conversionFunction) {
+            rhs = code `${conversionFunction}(${parameterVariable})`;
+        }
+        else if (validationFunction) {
+            rhs = code `${validationFunction}(${this.namedObjectType.name}.schema.properties.${this.name}.type(), ${parameterVariable})`;
+        }
+        else {
+            rhs = code `${this.reusables.imports.Either}.of(${parameterVariable})`;
+        }
+        return Maybe.of(code `${this.name}: ${rhs}`);
     }
     fromJsonInitializer({ variables, }) {
         return Maybe.of(code `${this.name}: ${this.type.fromJsonExpression({

package/dist/generators/ts/_snippets/snippets_ConversionFunction.d.ts

@@ -0,0 +1,3 @@
+import type { SnippetFactory } from "../SnippetFactory.js";
+export declare const snippets_ConversionFunction: SnippetFactory;
+//# sourceMappingURL=snippets_ConversionFunction.d.ts.map

package/dist/generators/ts/_snippets/snippets_ConversionFunction.js

@@ -0,0 +1,4 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_ConversionFunction = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}ConversionFunction`, code `\
+type ${syntheticNamePrefix}ConversionFunction<SourceT, TargetT> = (source: SourceT) => ${imports.Either}<Error, TargetT>;`);
+//# sourceMappingURL=snippets_ConversionFunction.js.map

package/dist/generators/ts/_snippets/snippets_ValidationFunction.d.ts

@@ -0,0 +1,3 @@
+import type { SnippetFactory } from "../SnippetFactory.js";
+export declare const snippets_ValidationFunction: SnippetFactory;
+//# sourceMappingURL=snippets_ValidationFunction.d.ts.map

package/dist/generators/ts/_snippets/snippets_ValidationFunction.js

@@ -0,0 +1,4 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_ValidationFunction = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}ValidationFunction`, code `\
+type ${syntheticNamePrefix}ValidationFunction<SchemaT, ValueT> = (schema: SchemaT, value: ValueT) => ${imports.Either}<Error, ValueT>;`);
+//# sourceMappingURL=snippets_ValidationFunction.js.map

package/dist/generators/ts/_snippets/snippets_convertToArray.d.ts

@@ -0,0 +1,3 @@
+import type { SnippetFactory } from "../SnippetFactory.js";
+export declare const snippets_convertToArray: SnippetFactory;
+//# sourceMappingURL=snippets_convertToArray.d.ts.map

package/dist/generators/ts/_snippets/snippets_convertToArray.js

@@ -0,0 +1,8 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_convertToArray = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToArray`, code `\
+function ${syntheticNamePrefix}convertToArray<ItemSourceT, ItemTargetT, Readonly extends boolean>(convertToItem: ${snippets.ConversionFunction}<ItemSourceT, ItemTargetT>, _readonly: Readonly) {
+  type EitherR = Readonly extends true ? ReadonlyArray<ItemTargetT> : Array<ItemTargetT>;
+  return (value: readonly ItemSourceT[] | undefined): ${imports.Either}<Error, EitherR> => 
+    (typeof value === "undefined" ? ${imports.Either}.of([]) : ${imports.Either}.sequence(value.map(convertToItem))) as ${imports.Either}<Error, EitherR>;
+}`);
+//# sourceMappingURL=snippets_convertToArray.js.map

package/dist/generators/ts/_snippets/snippets_convertToBlankNode.js

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_convertToBlankNode = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToBlankNode`, code `\
-function ${syntheticNamePrefix}convertToBlankNode(_schema: ${snippets.BlankNodeSchema}, value: ${imports.BlankNode} | undefined): ${imports.Either}<Error, ${imports.BlankNode}> {
+export const snippets_convertToBlankNode = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToBlankNode`, code `\
+function ${syntheticNamePrefix}convertToBlankNode(value: ${imports.BlankNode} | undefined): ${imports.Either}<Error, ${imports.BlankNode}> {
   switch (typeof value) {
     case "object":
       return ${imports.Either}.of(value);

package/dist/generators/ts/_snippets/snippets_convertToIdentifier.js

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_convertToIdentifier = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToIdentifier`, code `\
-function ${syntheticNamePrefix}convertToIdentifier(_schema: ${snippets.IdentifierSchema}, value: ${imports.BlankNode} | ${imports.NamedNode} | string | undefined): ${imports.Either}<Error, ${imports.BlankNode} | ${imports.NamedNode}> {
+export const snippets_convertToIdentifier = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToIdentifier`, code `\
+function ${syntheticNamePrefix}convertToIdentifier(value: ${imports.BlankNode} | ${imports.NamedNode} | string | undefined): ${imports.Either}<Error, ${imports.BlankNode} | ${imports.NamedNode}> {
   switch (typeof value) {
     case "object":
       return ${imports.Either}.of(value);

package/dist/generators/ts/_snippets/snippets_convertToIri.js

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_convertToIri = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToIri`, code `\
-function ${syntheticNamePrefix}convertToIri<IriT extends string = string>(_schema: ${snippets.IriSchema}, value: IriT | ${imports.NamedNode}<IriT>): ${imports.Either}<Error, ${imports.NamedNode}<IriT>> {
+export const snippets_convertToIri = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToIri`, code `\
+function ${syntheticNamePrefix}convertToIri<IriT extends string = string>(value: IriT | ${imports.NamedNode}<IriT>): ${imports.Either}<Error, ${imports.NamedNode}<IriT>> {
   switch (typeof value) {
     case "object":
       return ${imports.Either}.of(value);

package/dist/generators/ts/_snippets/snippets_convertToLazyObject.js

@@ -1,7 +1,7 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_convertToLazyObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToLazyObject`, code `\
 function ${syntheticNamePrefix}convertToLazyObject<ObjectIdentifierT extends ${imports.BlankNode} | ${imports.NamedNode}, PartialObjectT extends { ${syntheticNamePrefix}identifier: () => ObjectIdentifierT }, ResolvedObjectT extends { ${syntheticNamePrefix}identifier: () => ObjectIdentifierT }>(resolvedToPartial: (resolved: ResolvedObjectT) => PartialObjectT) {
-  return (_schema: unknown, value: ${snippets.LazyObject}<ObjectIdentifierT, PartialObjectT, ResolvedObjectT> | ResolvedObjectT): ${imports.Either}<Error, ${snippets.LazyObject}<ObjectIdentifierT, PartialObjectT, ResolvedObjectT>> => {
+  return (value: ${snippets.LazyObject}<ObjectIdentifierT, PartialObjectT, ResolvedObjectT> | ResolvedObjectT): ${imports.Either}<Error, ${snippets.LazyObject}<ObjectIdentifierT, PartialObjectT, ResolvedObjectT>> => {
     if (value instanceof ${snippets.LazyObject}) {
       return ${imports.Either}.of(value);
     }

package/dist/generators/ts/_snippets/snippets_convertToLazyObjectOption.js

@@ -1,7 +1,7 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_convertToLazyObjectOption = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToLazyObjectOption`, code `\
 function ${syntheticNamePrefix}convertToLazyObjectOption<ObjectIdentifierT extends ${imports.BlankNode} | ${imports.NamedNode}, PartialObjectT extends { ${syntheticNamePrefix}identifier: () => ObjectIdentifierT }, ResolvedObjectT extends { ${syntheticNamePrefix}identifier: () => ObjectIdentifierT }>(resolvedToPartial: (resolved: ResolvedObjectT) => PartialObjectT) {
-  return (_schema: unknown, value: ${snippets.LazyObjectOption}<ObjectIdentifierT, PartialObjectT, ResolvedObjectT> | ${imports.Maybe}<ResolvedObjectT> | ResolvedObjectT | undefined): ${imports.Either}<Error, ${snippets.LazyObjectOption}<ObjectIdentifierT, PartialObjectT, ResolvedObjectT>> => {
+  return (value: ${snippets.LazyObjectOption}<ObjectIdentifierT, PartialObjectT, ResolvedObjectT> | ${imports.Maybe}<ResolvedObjectT> | ResolvedObjectT | undefined): ${imports.Either}<Error, ${snippets.LazyObjectOption}<ObjectIdentifierT, PartialObjectT, ResolvedObjectT>> => {
     switch (typeof value) {
       case "object": {
         if (value instanceof ${snippets.LazyObjectOption}) {

package/dist/generators/ts/_snippets/snippets_convertToLazyObjectSet.js

@@ -1,7 +1,7 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_convertToLazyObjectSet = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToLazyObjectSet`, code `\
 function ${syntheticNamePrefix}convertToLazyObjectSet<ObjectIdentifierT extends ${imports.BlankNode} | ${imports.NamedNode}, PartialObjectT extends { ${syntheticNamePrefix}identifier: () => ObjectIdentifierT }, ResolvedObjectT extends { ${syntheticNamePrefix}identifier: () => ObjectIdentifierT }>(resolvedToPartial: (resolved: ResolvedObjectT) => PartialObjectT) {
-  return (_schema: unknown, value: ${snippets.LazyObjectSet}<ObjectIdentifierT, PartialObjectT, ResolvedObjectT> | readonly ResolvedObjectT[] | undefined): ${imports.Either}<Error, ${snippets.LazyObjectSet}<ObjectIdentifierT, PartialObjectT, ResolvedObjectT>> => {
+  return (value: ${snippets.LazyObjectSet}<ObjectIdentifierT, PartialObjectT, ResolvedObjectT> | readonly ResolvedObjectT[] | undefined): ${imports.Either}<Error, ${snippets.LazyObjectSet}<ObjectIdentifierT, PartialObjectT, ResolvedObjectT>> => {
     switch (typeof value) {
       case "object": {
         if (value instanceof ${snippets.LazyObjectSet}) {

package/dist/generators/ts/_snippets/snippets_convertToLiteral.js

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_convertToLiteral = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToLiteral`, code `\
-function ${syntheticNamePrefix}convertToLiteral(_schema: ${snippets.LiteralSchema}, value: bigint | boolean | Date | number | string | ${imports.Literal}): ${imports.Either}<Error, ${imports.Literal}> {
+function ${syntheticNamePrefix}convertToLiteral(value: bigint | boolean | Date | number | string | ${imports.Literal}): ${imports.Either}<Error, ${imports.Literal}> {
   if (typeof value === "object") {
     if (value instanceof Date) {
       return ${imports.Either}.of(${snippets.literalFactory}.date(value));

package/dist/generators/ts/_snippets/snippets_convertToMaybe.js

@@ -1,7 +1,7 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_convertToMaybe = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToMaybe`, code `\
-function ${syntheticNamePrefix}convertToMaybe<ItemSchemaT, ItemSourceT, ItemTargetT>(convertToItem: (schema: ItemSchemaT, value: ItemSourceT) => ${imports.Either}<Error, ItemTargetT>) {
-  return (schema: ${snippets.MaybeSchema}<ItemSchemaT>, value: ItemSourceT | ${imports.Maybe}<ItemTargetT> | undefined): ${imports.Either}<Error, ${imports.Maybe}<ItemTargetT>> => {
+function ${syntheticNamePrefix}convertToMaybe<ItemSourceT, ItemTargetT>(convertToItem: ${snippets.ConversionFunction}<ItemSourceT, ItemTargetT>) {
+  return (value: ItemSourceT | ${imports.Maybe}<ItemTargetT> | undefined): ${imports.Either}<Error, ${imports.Maybe}<ItemTargetT>> => {
     switch (typeof value) {
       case "object": {
         if (${imports.Maybe}.isMaybe(value)) {
@@ -13,7 +13,7 @@ function ${syntheticNamePrefix}convertToMaybe<ItemSchemaT, ItemSourceT, ItemTarg
         return ${imports.Either}.of(${imports.Maybe}.empty());
     }
 
-    return convertToItem(schema.item(), value).map(${imports.Maybe}.of);
+    return convertToItem(value).map(${imports.Maybe}.of);
   }
 }`);
 //# sourceMappingURL=snippets_convertToMaybe.js.map

package/dist/generators/ts/_snippets/snippets_convertWithDefaultValue.js

@@ -1,11 +1,11 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_convertWithDefaultValue = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertWithDefaultValue`, code `\
-function ${syntheticNamePrefix}convertWithDefaultValue<DefaultValueT extends ItemSourceT, ItemSchemaT, ItemSourceT, ItemTargetT>(convertToItem: (schema: ItemSchemaT, value: ItemSourceT) => ${imports.Either}<Error, ItemTargetT>) {
-  return (schema: ${snippets.DefaultValueSchema}<DefaultValueT, ItemSchemaT>, value: ItemSourceT | undefined): ${imports.Either}<Error, ItemTargetT> => {
+function ${syntheticNamePrefix}convertWithDefaultValue<ItemSourceT, ItemTargetT>(convertToItem: ${snippets.ConversionFunction}<ItemSourceT, ItemTargetT>, defaultValue: ItemSourceT) {
+  return (value: ItemSourceT | undefined): ${imports.Either}<Error, ItemTargetT> => {
     if (typeof value === "undefined") {
-      return convertToItem(schema.item(), schema.defaultValue);
+      return convertToItem(defaultValue);
     }
-    return convertToItem(schema.item(), value);
+    return convertToItem(value);
   }
 }`);
 //# sourceMappingURL=snippets_convertWithDefaultValue.js.map

package/dist/generators/ts/_snippets/snippets_identityConversionFunction.d.ts

@@ -0,0 +1,3 @@
+import type { SnippetFactory } from "../SnippetFactory.js";
+export declare const snippets_identityConversionFunction: SnippetFactory;
+//# sourceMappingURL=snippets_identityConversionFunction.d.ts.map

package/dist/generators/ts/_snippets/snippets_identityConversionFunction.js

@@ -0,0 +1,6 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_identityConversionFunction = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}identityConversionFunction`, code `\
+function ${syntheticNamePrefix}identityConversionFunction<T>(value: T): ${imports.Either}<Error, T> {
+  return ${imports.Either}.of(value);
+}`);
+//# sourceMappingURL=snippets_identityConversionFunction.js.map

package/dist/generators/ts/_snippets/snippets_identityValidationFunction.d.ts

@@ -0,0 +1,3 @@
+import type { SnippetFactory } from "../SnippetFactory.js";
+export declare const snippets_identityValidationFunction: SnippetFactory;
+//# sourceMappingURL=snippets_identityValidationFunction.d.ts.map

package/dist/generators/ts/_snippets/snippets_identityValidationFunction.js

@@ -0,0 +1,6 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_identityValidationFunction = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}identityValidationFunction`, code `\
+function ${syntheticNamePrefix}identityValidationFunction<T>(_schema: unknown, value: T): ${imports.Either}<Error, T> {
+  return ${imports.Either}.of(value);
+}`);
+//# sourceMappingURL=snippets_identityValidationFunction.js.map

package/dist/generators/ts/_snippets/snippets_validateArray.d.ts

@@ -0,0 +1,3 @@
+import type { SnippetFactory } from "../SnippetFactory.js";
+export declare const snippets_validateArray: SnippetFactory;
+//# sourceMappingURL=snippets_validateArray.d.ts.map

package/dist/generators/ts/_snippets/snippets_validateArray.js

@@ -0,0 +1,13 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_validateArray = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}validateArray`, code `\
+function ${syntheticNamePrefix}validateArray<ItemSchemaT, ItemValueT, Readonly extends boolean>(validateItem: ${snippets.ValidationFunction}<ItemSchemaT, ItemValueT>, _readonly: Readonly) {
+  type EitherR = Readonly extends true ? ReadonlyArray<ItemValueT> : Array<ItemValueT>;
+  return (schema: ${snippets.CollectionSchema}<ItemSchemaT>, valueArray: readonly ItemValueT[]): ${imports.Either}<Error, EitherR> => {
+    if (schema.minCount !== undefined && valueArray.length < schema.minCount) {
+      return ${imports.Left}(new Error(\`value array has length (\${valueArray.length}) less than minCount (\${schema.minCount})\`)) as ${imports.Either}<Error, EitherR>;
+    }
+
+    return ${imports.Either}.sequence(valueArray.map(value => validateItem(schema.item(), value))) as ${imports.Either}<Error, EitherR>;
+  }
+}`);
+//# sourceMappingURL=snippets_validateArray.js.map

package/dist/generators/ts/_snippets/snippets_validateMaybe.d.ts

@@ -0,0 +1,3 @@
+import type { SnippetFactory } from "../SnippetFactory.js";
+export declare const snippets_validateMaybe: SnippetFactory;
+//# sourceMappingURL=snippets_validateMaybe.d.ts.map

package/dist/generators/ts/_snippets/snippets_validateMaybe.js

@@ -0,0 +1,7 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_validateMaybe = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}validateMaybe`, code `\
+function ${syntheticNamePrefix}validateMaybe<ItemSchemaT, ItemValueT>(validateItem: ${snippets.ValidationFunction}<ItemSchemaT, ItemValueT>) {
+  return (schema: ${snippets.MaybeSchema}<ItemSchemaT>, valueMaybe: ${imports.Maybe}<ItemValueT>): ${imports.Either}<Error, ${imports.Maybe}<ItemValueT>> =>
+    valueMaybe.map(value => validateItem(schema.item(), value).map(() => valueMaybe)).orDefault(${imports.Either}.of(valueMaybe));
+}`);
+//# sourceMappingURL=snippets_validateMaybe.js.map

package/dist/input/generated.d.ts

@@ -178,7 +178,7 @@ export interface PropertyShape {
 }
 export declare namespace PropertyShape {
     function create(parameters: {
-        readonly $identifier?: (() => PropertyShape.Identifier) | (BlankNode | NamedNode) | string;
+        readonly $identifier?: (() => PropertyShape.Identifier) | BlankNode | NamedNode | string;
         readonly and?: readonly (BlankNode | NamedNode | string | undefined)[] | Maybe<readonly (BlankNode | NamedNode)[]>;
         readonly classes?: readonly (string | NamedNode)[];
         readonly comment?: string | Maybe<string>;
@@ -217,7 +217,7 @@ export declare namespace PropertyShape {
         readonly xone?: readonly (BlankNode | NamedNode | string | undefined)[] | Maybe<readonly (BlankNode | NamedNode)[]>;
     }): Either<Error, PropertyShape>;
     function createUnsafe(parameters: {
-        readonly $identifier?: (() => PropertyShape.Identifier) | (BlankNode | NamedNode) | string;
+        readonly $identifier?: (() => PropertyShape.Identifier) | BlankNode | NamedNode | string;
         readonly and?: readonly (BlankNode | NamedNode | string | undefined)[] | Maybe<readonly (BlankNode | NamedNode)[]>;
         readonly classes?: readonly (string | NamedNode)[];
         readonly comment?: string | Maybe<string>;
@@ -708,12 +708,12 @@ export interface PropertyGroup {
 }
 export declare namespace PropertyGroup {
     function create(parameters?: {
-        readonly $identifier?: (() => PropertyGroup.Identifier) | (BlankNode | NamedNode) | string;
+        readonly $identifier?: (() => PropertyGroup.Identifier) | BlankNode | NamedNode | string;
         readonly comment?: string | Maybe<string>;
         readonly label?: string | Maybe<string>;
     }): Either<Error, PropertyGroup>;
     function createUnsafe(parameters?: {
-        readonly $identifier?: (() => PropertyGroup.Identifier) | (BlankNode | NamedNode) | string;
+        readonly $identifier?: (() => PropertyGroup.Identifier) | BlankNode | NamedNode | string;
         readonly comment?: string | Maybe<string>;
         readonly label?: string | Maybe<string>;
     }): PropertyGroup;
@@ -784,12 +784,12 @@ export interface Ontology {
 }
 export declare namespace Ontology {
     function create(parameters?: {
-        readonly $identifier?: (() => Ontology.Identifier) | (BlankNode | NamedNode) | string;
+        readonly $identifier?: (() => Ontology.Identifier) | BlankNode | NamedNode | string;
         readonly comment?: string | Maybe<string>;
         readonly label?: string | Maybe<string>;
     }): Either<Error, Ontology>;
     function createUnsafe(parameters?: {
-        readonly $identifier?: (() => Ontology.Identifier) | (BlankNode | NamedNode) | string;
+        readonly $identifier?: (() => Ontology.Identifier) | BlankNode | NamedNode | string;
         readonly comment?: string | Maybe<string>;
         readonly label?: string | Maybe<string>;
     }): Ontology;
@@ -896,7 +896,7 @@ export interface NodeShape {
 }
 export declare namespace NodeShape {
     function create(parameters?: {
-        readonly $identifier?: (() => NodeShape.Identifier) | (BlankNode | NamedNode) | string;
+        readonly $identifier?: (() => NodeShape.Identifier) | BlankNode | NamedNode | string;
         readonly and?: readonly (BlankNode | NamedNode | string | undefined)[] | Maybe<readonly (BlankNode | NamedNode)[]>;
         readonly classes?: readonly (string | NamedNode)[];
         readonly closed?: boolean | Maybe<boolean>;
@@ -937,7 +937,7 @@ export declare namespace NodeShape {
         readonly xone?: readonly (BlankNode | NamedNode | string | undefined)[] | Maybe<readonly (BlankNode | NamedNode)[]>;
     }): Either<Error, NodeShape>;
     function createUnsafe(parameters?: {
-        readonly $identifier?: (() => NodeShape.Identifier) | (BlankNode | NamedNode) | string;
+        readonly $identifier?: (() => NodeShape.Identifier) | BlankNode | NamedNode | string;
         readonly and?: readonly (BlankNode | NamedNode | string | undefined)[] | Maybe<readonly (BlankNode | NamedNode)[]>;
         readonly classes?: readonly (string | NamedNode)[];
         readonly closed?: boolean | Maybe<boolean>;