@typia/utils 12.0.0-dev.20260225

package/src/validators/internal/OpenApiArrayValidator.ts

@@ -0,0 +1,49 @@
+import { OpenApi } from "@typia/interface";
+
+import { _isUniqueItems } from "../functional/_isUniqueItems";
+import { IOpenApiValidatorContext } from "./IOpenApiValidatorContext";
+import { OpenApiStationValidator } from "./OpenApiStationValidator";
+
+export namespace OpenApiArrayValidator {
+  export const validate = (
+    ctx: IOpenApiValidatorContext<OpenApi.IJsonSchema.IArray>,
+  ): boolean => {
+    if (Array.isArray(ctx.value) === false) return ctx.report(ctx);
+    return [
+      ctx.value
+        .map((value, i) =>
+          OpenApiStationValidator.validate({
+            ...ctx,
+            schema: ctx.schema.items,
+            value,
+            path: `${ctx.path}[${i}]`,
+            required: true,
+          }),
+        )
+        .every((v) => v),
+      ctx.schema.minItems !== undefined
+        ? ctx.value.length >= ctx.schema.minItems ||
+          ctx.report({
+            ...ctx,
+            expected: `Array<> & MinItems<${ctx.schema.minItems}>`,
+          })
+        : true,
+      ctx.schema.maxItems !== undefined
+        ? ctx.value.length <= ctx.schema.maxItems ||
+          ctx.report({
+            ...ctx,
+            expected: `Array<> & MaxItems<${ctx.schema.maxItems}>`,
+          })
+        : true,
+      ctx.schema.uniqueItems !== undefined
+        ? ctx.schema.uniqueItems
+          ? _isUniqueItems(ctx.value) ||
+            ctx.report({
+              ...ctx,
+              expected: `Array<> & UniqueItems`,
+            })
+          : true
+        : true,
+    ].every((v) => v);
+  };
+}

package/src/validators/internal/OpenApiBooleanValidator.ts

@@ -0,0 +1,11 @@
+import { OpenApi } from "@typia/interface";
+
+import { IOpenApiValidatorContext } from "./IOpenApiValidatorContext";
+
+export namespace OpenApiBooleanValidator {
+  export const validate = (
+    ctx: IOpenApiValidatorContext<OpenApi.IJsonSchema.IBoolean>,
+  ): boolean => {
+    return typeof ctx.value === "boolean" || ctx.report(ctx);
+  };
+}

package/src/validators/internal/OpenApiConstantValidator.ts

@@ -0,0 +1,11 @@
+import { OpenApi } from "@typia/interface";
+
+import { IOpenApiValidatorContext } from "./IOpenApiValidatorContext";
+
+export namespace OpenApiConstantValidator {
+  export const validate = (
+    ctx: IOpenApiValidatorContext<OpenApi.IJsonSchema.IConstant>,
+  ): boolean => {
+    return ctx.value === ctx.schema.const || ctx.report(ctx);
+  };
+}

package/src/validators/internal/OpenApiIntegerValidator.ts

@@ -0,0 +1,49 @@
+import { OpenApi } from "@typia/interface";
+
+import { IOpenApiValidatorContext } from "./IOpenApiValidatorContext";
+
+export namespace OpenApiIntegerValidator {
+  export const validate = (
+    ctx: IOpenApiValidatorContext<OpenApi.IJsonSchema.IInteger>,
+  ): boolean => {
+    if (typeof ctx.value !== "number" || Math.floor(ctx.value) !== ctx.value)
+      return ctx.report(ctx);
+    return [
+      ctx.schema.minimum !== undefined
+        ? ctx.value >= ctx.schema.minimum ||
+          ctx.report({
+            ...ctx,
+            expected: `number & Type<"int32"> & Minimum<${ctx.schema.minimum}>`,
+          })
+        : true,
+      ctx.schema.maximum !== undefined
+        ? ctx.value <= ctx.schema.maximum ||
+          ctx.report({
+            ...ctx,
+            expected: `number & Type<"int32"> & Maximum<${ctx.schema.maximum}>`,
+          })
+        : true,
+      ctx.schema.exclusiveMinimum !== undefined
+        ? ctx.value > ctx.schema.exclusiveMinimum ||
+          ctx.report({
+            ...ctx,
+            expected: `number & Type<"int32"> & ExclusiveMinimum<${ctx.schema.exclusiveMinimum}>`,
+          })
+        : true,
+      ctx.schema.exclusiveMaximum !== undefined
+        ? ctx.value < ctx.schema.exclusiveMaximum ||
+          ctx.report({
+            ...ctx,
+            expected: `number & Type<"int32"> & ExclusiveMaximum<${ctx.schema.exclusiveMaximum}>`,
+          })
+        : true,
+      ctx.schema.multipleOf !== undefined
+        ? ctx.value % ctx.schema.multipleOf === 0 ||
+          ctx.report({
+            ...ctx,
+            expected: `number & Type<"int32"> & MultipleOf<${ctx.schema.multipleOf}>`,
+          })
+        : true,
+    ].every((v) => v);
+  };
+}

package/src/validators/internal/OpenApiNumberValidator.ts

@@ -0,0 +1,48 @@
+import { OpenApi } from "@typia/interface";
+
+import { IOpenApiValidatorContext } from "./IOpenApiValidatorContext";
+
+export namespace OpenApiNumberValidator {
+  export const validate = (
+    ctx: IOpenApiValidatorContext<OpenApi.IJsonSchema.INumber>,
+  ): boolean => {
+    if (typeof ctx.value !== "number") return ctx.report(ctx);
+    return [
+      ctx.schema.minimum !== undefined
+        ? ctx.value >= ctx.schema.minimum ||
+          ctx.report({
+            ...ctx,
+            expected: `number & Minimum<${ctx.schema.minimum}>`,
+          })
+        : true,
+      ctx.schema.maximum !== undefined
+        ? ctx.value <= ctx.schema.maximum ||
+          ctx.report({
+            ...ctx,
+            expected: `number & Maximum<${ctx.schema.maximum}>`,
+          })
+        : true,
+      ctx.schema.exclusiveMinimum !== undefined
+        ? ctx.value > ctx.schema.exclusiveMinimum ||
+          ctx.report({
+            ...ctx,
+            expected: `number & ExclusiveMinimum<${ctx.schema.exclusiveMinimum}>`,
+          })
+        : true,
+      ctx.schema.exclusiveMaximum !== undefined
+        ? ctx.value < ctx.schema.exclusiveMaximum ||
+          ctx.report({
+            ...ctx,
+            expected: `number & ExclusiveMaximum<${ctx.schema.exclusiveMaximum}>`,
+          })
+        : true,
+      ctx.schema.multipleOf !== undefined
+        ? ctx.value % ctx.schema.multipleOf === 0 ||
+          ctx.report({
+            ...ctx,
+            expected: `number & MultipleOf<${ctx.schema.multipleOf}>`,
+          })
+        : true,
+    ].every((v) => v);
+  };
+}

package/src/validators/internal/OpenApiObjectValidator.ts

@@ -0,0 +1,83 @@
+import { OpenApi } from "@typia/interface";
+
+import { NamingConvention } from "../../utils/NamingConvention";
+import { IOpenApiValidatorContext } from "./IOpenApiValidatorContext";
+import { OpenApiStationValidator } from "./OpenApiStationValidator";
+
+export namespace OpenApiObjectValidator {
+  export const validate = (
+    ctx: IOpenApiValidatorContext<OpenApi.IJsonSchema.IObject>,
+  ): boolean => {
+    if (typeof ctx.value !== "object" || ctx.value === null)
+      return ctx.report(ctx);
+    return [
+      ...Object.entries(ctx.schema.properties ?? {}).map(([key, value]) =>
+        OpenApiStationValidator.validate({
+          ...ctx,
+          schema: value,
+          value: (ctx.value as Record<string, any>)[key],
+          path:
+            ctx.path +
+            (NamingConvention.variable(key)
+              ? `.${key}`
+              : `[${JSON.stringify(key)}]`),
+          required: ctx.schema.required?.includes(key) ?? false,
+        }),
+      ),
+      ...(typeof ctx.schema.additionalProperties === "object" &&
+      ctx.schema.additionalProperties !== null
+        ? Object.entries(ctx.value)
+            .filter(
+              ([key]) =>
+                Object.keys(ctx.schema.properties ?? {}).includes(key) ===
+                false,
+            )
+            .map(([key, value]) =>
+              OpenApiStationValidator.validate({
+                ...ctx,
+                schema: ctx.schema.additionalProperties as OpenApi.IJsonSchema,
+                value,
+                path:
+                  ctx.path +
+                  (NamingConvention.variable(key)
+                    ? `.${key}`
+                    : `[${JSON.stringify(key)}]`),
+                required: true,
+              }),
+            )
+        : []),
+      ...(ctx.equals === true &&
+      (ctx.schema.additionalProperties ?? false) === false
+        ? [validateEquals(ctx)]
+        : []),
+    ].every((v) => v);
+  };
+
+  const validateEquals = (
+    ctx: IOpenApiValidatorContext<OpenApi.IJsonSchema.IObject>,
+  ): boolean => {
+    const regular: Set<string> = new Set(
+      Object.keys(ctx.schema.properties ?? {}),
+    );
+    return Object.entries(ctx.value as object)
+      .map(([key, value]) => {
+        if (regular.has(key) === true) return true;
+        return ctx.report({
+          ...ctx,
+          path:
+            ctx.path +
+            (NamingConvention.variable(key)
+              ? `.${key}`
+              : `[${JSON.stringify(key)}]`),
+          value,
+          expected: "undefined",
+          description: [
+            `The property \`${key}\` is not defined in the object type.`,
+            "",
+            "Please remove the property next time.",
+          ].join("\n"),
+        });
+      })
+      .every((v) => v);
+  };
+}

package/src/validators/internal/OpenApiOneOfValidator.ts

@@ -0,0 +1,309 @@
+import { OpenApi } from "@typia/interface";
+
+import { MapUtil } from "../../utils";
+import { OpenApiTypeChecker } from "../OpenApiTypeChecker";
+import { IOpenApiValidatorContext } from "./IOpenApiValidatorContext";
+import { OpenApiStationValidator } from "./OpenApiStationValidator";
+
+export namespace OpenApiOneOfValidator {
+  export const validate = (
+    ctx: IOpenApiValidatorContext<OpenApi.IJsonSchema.IOneOf>,
+  ): boolean => {
+    const discriminator: IDiscriminator = getDiscriminator(ctx);
+    for (const item of discriminator.branches)
+      if (item.predicator(ctx.value))
+        return OpenApiStationValidator.validate({
+          ...ctx,
+          schema: item.schema,
+        });
+    if (discriminator.branches.length !== 0)
+      return validate({
+        ...ctx,
+        schema: {
+          oneOf: discriminator.remainders,
+        },
+      });
+    const matched: OpenApi.IJsonSchema | undefined =
+      discriminator.remainders.find(
+        (schema) =>
+          OpenApiStationValidator.validate({
+            ...ctx,
+            schema,
+            exceptionable: false,
+            equals: false,
+          }) === true,
+      );
+    if (matched === undefined) return ctx.report(ctx);
+    return ctx.equals === true
+      ? OpenApiStationValidator.validate({
+          ...ctx,
+          schema: matched,
+        })
+      : true;
+  };
+
+  const getDiscriminator = (
+    ctx: IOpenApiValidatorContext<OpenApi.IJsonSchema.IOneOf>,
+  ): IDiscriminator => {
+    const resolvedList: IFlatSchema[] = ctx.schema.oneOf.map((schema) =>
+      getFlattened({
+        components: ctx.components,
+        schema,
+        visited: new Set(),
+      }),
+    );
+
+    // FIND ANY TYPE
+    const anything: IFlatSchema | undefined = resolvedList.find((resolved) =>
+      OpenApiTypeChecker.isUnknown(resolved.escaped),
+    );
+    if (anything)
+      return {
+        branches: [],
+        remainders: [anything.schema],
+      };
+
+    // CHECK NULLABLES
+    const nullables: IFlatSchema<OpenApi.IJsonSchema.INull>[] =
+      resolvedList.filter(
+        (resolved): resolved is IFlatSchema<OpenApi.IJsonSchema.INull> =>
+          OpenApiTypeChecker.isNull(resolved.schema),
+      );
+    const significant: IFlatSchema<OpenApi.IJsonSchema>[] = resolvedList.filter(
+      (resolved) => false === OpenApiTypeChecker.isNull(resolved.escaped),
+    );
+    if (significant.length === 1)
+      return {
+        branches: [
+          {
+            schema: significant[0]!.schema,
+            predicator: (value) => value !== null,
+          },
+        ],
+        remainders: nullables.map((nullable) => nullable.schema),
+      };
+
+    // DISCRIMINATIONS
+    const tuples = significant.filter((flat) =>
+      OpenApiTypeChecker.isTuple(flat.escaped),
+    );
+    const arrays = significant.filter(
+      (flat): flat is IFlatSchema<OpenApi.IJsonSchema.IArray> =>
+        OpenApiTypeChecker.isArray(flat.escaped),
+    );
+    const branches: IDiscriminatorBranch[] = [
+      ...(tuples.length === 0 && arrays.length !== 0
+        ? discriminateArrays(
+            ctx,
+            significant.filter(
+              (flat): flat is IFlatSchema<OpenApi.IJsonSchema.IArray> =>
+                OpenApiTypeChecker.isArray(flat.schema),
+            ),
+          )
+        : []),
+      ...discriminateObjects(
+        ctx,
+        significant.filter(
+          (flat): flat is IFlatSchema<OpenApi.IJsonSchema.IObject> =>
+            OpenApiTypeChecker.isObject(flat.escaped),
+        ),
+        tuples.length + arrays.length === 0,
+      ),
+    ];
+    return {
+      branches,
+      remainders: ctx.schema.oneOf.filter(
+        (x) => branches.some((y) => y.schema === x) === false,
+      ),
+    };
+  };
+
+  const discriminateArrays = (
+    ctx: IOpenApiValidatorContext<OpenApi.IJsonSchema.IOneOf>,
+    arraySchemas: IFlatSchema<OpenApi.IJsonSchema.IArray>[],
+  ): IDiscriminatorBranch[] => {
+    if (arraySchemas.length === 1)
+      return [
+        {
+          schema: arraySchemas[0]!.schema,
+          predicator: (value) => Array.isArray(value),
+        },
+      ];
+    return arraySchemas
+      .filter((flat, i, array) =>
+        array.every(
+          (item, j) =>
+            i === j ||
+            OpenApiTypeChecker.covers({
+              components: ctx.components,
+              x: item.escaped.items,
+              y: flat.escaped.items,
+            }) === false,
+        ),
+      )
+      .map(
+        (flat) =>
+          ({
+            schema: flat.schema,
+            predicator: (value) =>
+              Array.isArray(value) &&
+              (value.length === 0 ||
+                OpenApiStationValidator.validate({
+                  ...ctx,
+                  schema: (flat.escaped as OpenApi.IJsonSchema.IArray).items,
+                  value: value[0]!,
+                  path: `${ctx.path}[0]`,
+                  exceptionable: false,
+                  equals: false,
+                })),
+          }) satisfies IDiscriminatorBranch,
+      );
+  };
+
+  const discriminateObjects = (
+    ctx: IOpenApiValidatorContext<OpenApi.IJsonSchema.IOneOf>,
+    objectSchemas: IFlatSchema<OpenApi.IJsonSchema.IObject>[],
+    noArray: boolean,
+  ): IDiscriminatorBranch[] => {
+    if (objectSchemas.length === 1)
+      return [
+        {
+          schema: objectSchemas[0]!.schema,
+          predicator: noArray
+            ? (value) => typeof value === "object" && value !== null
+            : (value) =>
+                typeof value === "object" &&
+                value !== null &&
+                Array.isArray(value) === false,
+        },
+      ];
+
+    // KEEP ONLY REQUIRED PROPERTIES
+    objectSchemas = objectSchemas
+      .filter(
+        (flat) =>
+          flat.escaped.properties !== undefined &&
+          flat.escaped.required !== undefined,
+      )
+      .map(
+        (flat) =>
+          ({
+            ...flat,
+            escaped: {
+              ...flat.escaped,
+              properties: Object.fromEntries(
+                Object.entries(flat.escaped.properties ?? {}).map(
+                  ([key, value]) => [
+                    key,
+                    getFlattened({
+                      components: ctx.components,
+                      schema: value,
+                      visited: new Set(),
+                    }).escaped,
+                  ],
+                ),
+              ),
+            },
+          }) satisfies IFlatSchema<OpenApi.IJsonSchema.IObject>,
+      );
+
+    // PROPERTY MATRIX
+    const matrix: Map<string, Array<OpenApi.IJsonSchema | null>> = new Map();
+    objectSchemas.forEach((obj, i) => {
+      for (const [key, value] of Object.entries(obj.escaped.properties ?? {})) {
+        if (!!obj.escaped.required?.includes(key) === false) continue;
+        MapUtil.take(matrix, key, () =>
+          new Array(objectSchemas.length).fill(null),
+        )[i] = value;
+      }
+    });
+
+    // THE BRANCHES
+    return objectSchemas
+      .map((obj, i) => {
+        const candidates: string[] = [];
+        for (const [key, value] of Object.entries(
+          obj.escaped.properties ?? {},
+        )) {
+          if (!!obj.escaped.required?.includes(key) === false) continue;
+
+          const neighbors: OpenApi.IJsonSchema[] = matrix
+            .get(key)!
+            .filter((_oppo, j) => i !== j)
+            .filter((oppo) => oppo !== null);
+          const unique: boolean = OpenApiTypeChecker.isConstant(value)
+            ? neighbors.every(
+                (oppo) =>
+                  OpenApiTypeChecker.isConstant(oppo) &&
+                  value.const !== oppo.const,
+              )
+            : neighbors.length === 0;
+          if (unique) candidates.push(key);
+        }
+        if (candidates.length === 0) return null;
+        const top: string =
+          candidates.find((key) =>
+            OpenApiTypeChecker.isConstant(obj.escaped.properties![key]!),
+          ) ?? candidates[0]!;
+        const target: OpenApi.IJsonSchema = obj.escaped.properties![top]!;
+        return {
+          schema: obj.schema,
+          predicator: OpenApiTypeChecker.isConstant(target)
+            ? (value) =>
+                typeof value === "object" &&
+                value !== null &&
+                (value as any)[top] === target.const
+            : (value) =>
+                typeof value === "object" &&
+                value !== null &&
+                (value as any)[top] !== undefined,
+        } satisfies IDiscriminatorBranch;
+      })
+      .filter((b) => b !== null);
+  };
+}
+
+const getFlattened = (props: {
+  components: OpenApi.IComponents;
+  schema: OpenApi.IJsonSchema;
+  visited: Set<string>;
+}): IFlatSchema => {
+  if (OpenApiTypeChecker.isReference(props.schema)) {
+    const key: string = props.schema.$ref.split("/").pop() ?? "";
+    if (props.visited.has(key))
+      return {
+        schema: props.schema,
+        escaped: {},
+      };
+    props.visited.add(key);
+    return {
+      ...getFlattened({
+        components: props.components,
+        schema: props.components.schemas?.[key] ?? {},
+        visited: props.visited,
+      }),
+      schema: props.schema,
+    };
+  }
+  return {
+    schema: props.schema,
+    escaped: props.schema,
+  };
+};
+
+interface IDiscriminator {
+  branches: IDiscriminatorBranch[];
+  remainders: OpenApi.IJsonSchema[];
+}
+
+interface IDiscriminatorBranch {
+  schema: OpenApi.IJsonSchema;
+  predicator: (value: unknown) => boolean;
+}
+
+interface IFlatSchema<
+  Schema extends OpenApi.IJsonSchema = OpenApi.IJsonSchema,
+> {
+  schema: OpenApi.IJsonSchema;
+  escaped: Schema;
+}

package/src/validators/internal/OpenApiSchemaNamingRule.ts

@@ -0,0 +1,124 @@
+import { OpenApi } from "@typia/interface";
+
+import { OpenApiTypeChecker } from "../OpenApiTypeChecker";
+
+export namespace OpenApiSchemaNamingRule {
+  export const getName = (
+    schema: OpenApi.IJsonSchema,
+    union: boolean = false,
+  ): string => {
+    // COALESCE
+    if (OpenApiTypeChecker.isUnknown(schema)) return "unknown";
+    else if (OpenApiTypeChecker.isNull(schema)) return "null";
+    else if (OpenApiTypeChecker.isOneOf(schema))
+      return schema.oneOf.map((child) => getName(child, true)).join(" | ");
+    // ATOMICS
+    else if (OpenApiTypeChecker.isConstant(schema))
+      return JSON.stringify(schema.const);
+    else if (OpenApiTypeChecker.isBoolean(schema)) return "boolean";
+    else if (OpenApiTypeChecker.isInteger(schema))
+      return joinIntersection(getNameOfInteger(schema), union);
+    else if (OpenApiTypeChecker.isNumber(schema))
+      return joinIntersection(getNameOfNumber(schema), union);
+    else if (OpenApiTypeChecker.isString(schema))
+      return joinIntersection(getNameOfString(schema), union);
+    // INSTANCES
+    else if (OpenApiTypeChecker.isReference(schema))
+      return schema.$ref.split("/").pop() ?? "unknown";
+    else if (OpenApiTypeChecker.isObject(schema)) return "__object";
+    else if (OpenApiTypeChecker.isArray(schema))
+      return joinIntersection(getNameOfArray(schema), union);
+    else if (OpenApiTypeChecker.isTuple(schema)) return getNameOfTuple(schema);
+    return "unknown";
+  };
+
+  const getNameOfInteger = (schema: OpenApi.IJsonSchema.IInteger): string[] => [
+    "number",
+    ...(schema.minimum !== undefined
+      ? [
+          schema.exclusiveMinimum
+            ? `tags.ExclusiveMinimum<${schema.minimum}>`
+            : `tags.Minimum<${schema.minimum}>`,
+        ]
+      : []),
+    ...(schema.maximum !== undefined
+      ? [
+          schema.exclusiveMaximum
+            ? `tags.ExclusiveMaximum<${schema.maximum}>`
+            : `tags.Maximum<${schema.maximum}>`,
+        ]
+      : []),
+    ...(schema.multipleOf !== undefined
+      ? [`tags.MultipleOf<${schema.multipleOf}>`]
+      : []),
+  ];
+
+  const getNameOfNumber = (schema: OpenApi.IJsonSchema.INumber): string[] => [
+    "number",
+    ...(schema.minimum !== undefined
+      ? [
+          schema.exclusiveMinimum
+            ? `tags.ExclusiveMinimum<${schema.minimum}>`
+            : `tags.Minimum<${schema.minimum}>`,
+        ]
+      : []),
+    ...(schema.maximum !== undefined
+      ? [
+          schema.exclusiveMaximum
+            ? `tags.ExclusiveMaximum<${schema.maximum}>`
+            : `tags.Maximum<${schema.maximum}>`,
+        ]
+      : []),
+    ...(schema.multipleOf !== undefined
+      ? [`tags.MultipleOf<${schema.multipleOf}>`]
+      : []),
+  ];
+
+  const getNameOfString = (schema: OpenApi.IJsonSchema.IString): string[] => [
+    "string",
+    ...(schema.format !== undefined
+      ? [`tags.Format<${JSON.stringify(schema.format)}>`]
+      : []),
+    ...(schema.pattern !== undefined && schema.format === undefined
+      ? [`tags.Pattern<${JSON.stringify(schema.pattern)}>`]
+      : []),
+    ...(schema.contentMediaType !== undefined
+      ? [`tags.ContentMediaType<${JSON.stringify(schema.contentMediaType)}>`]
+      : []),
+    ...(schema.minLength !== undefined
+      ? [`tags.MinLength<${schema.minLength}>`]
+      : []),
+    ...(schema.maxLength !== undefined
+      ? [`tags.MaxLength<${schema.maxLength}>`]
+      : []),
+  ];
+
+  const getNameOfArray = (schema: OpenApi.IJsonSchema.IArray): string[] => [
+    `Array<${getName(schema.items)}>`,
+    ...(schema.minItems !== undefined
+      ? [`tags.MinItems<${schema.minItems}>`]
+      : []),
+    ...(schema.maxItems !== undefined
+      ? [`tags.MaxItems<${schema.maxItems}>`]
+      : []),
+    ...(schema.uniqueItems !== undefined ? [`tags.UniqueItems`] : []),
+  ];
+
+  const getNameOfTuple = (schema: OpenApi.IJsonSchema.ITuple): string =>
+    "[" +
+    [
+      ...schema.prefixItems.map((child) => getName(child)),
+      ...(schema.additionalItems === true
+        ? ["...Array<unknown>"]
+        : typeof schema.additionalItems === "object" &&
+            schema.additionalItems !== null
+          ? [`...Array<${getName(schema.additionalItems)}>`]
+          : []),
+    ].join(", ") +
+    "]";
+
+  const joinIntersection = (elements: string[], union: boolean): string => {
+    const str: string = elements.join(" & ");
+    return union ? `(${str})` : str;
+  };
+}