generator-jhipster 8.4.0 → 8.6.0

package/dist/types/jdl/converters/types.d.ts

@@ -1,18 +1,106 @@
 import { RelationshipType, RelationshipSide } from '../basic-types/relationships.js';
-export type Field = {
-    fieldName: string;
-    fieldType: string;
-    options?: Record<string, boolean | string | number>;
+import { GENERATOR_JHIPSTER } from '../../generators/index.js';
+
+export type JSONField = {
+  fieldName: string;
+  fieldType: string;
+  documentation?: string;
+  options?: Record<string, boolean | string | number>;
+  fieldValidateRules?: string[];
 } & Record<string, any>;
-export type Relationship = {
-    relationshipSide?: RelationshipSide;
-    relationshipName: string;
-    relationshipType: RelationshipType;
-    otherEntityName: string;
-    options?: Record<string, boolean | string | number>;
+
+export type JSONBlobField = {
+  fieldTypeBlobContent: 'image' | 'any' | 'text';
+} & JSONField;
+
+export type JSONFieldEnum = JSONField & {
+  fieldValues: string;
+  fieldTypeDocumentation?: string;
+  fieldValuesJavadocs?: Record<string, string>;
+};
+
+export type JSONFieldBlob = JSONField & {
+  fieldTypeBlobContent: string;
+};
+
+export type JSONRelationship = {
+  relationshipSide?: RelationshipSide;
+  relationshipName: string;
+  relationshipType: RelationshipType;
+  otherEntityName: string;
+  options?: Record<string, boolean | string | number>;
 } & Record<string, any>;
-export type Entity = {
-    documentation?: string;
-    fields?: Field[];
-    relationships?: Relationship[];
+
+export type JSONEntity = {
+  documentation?: string;
+  fields?: JSONField[];
+  relationships?: JSONRelationship[];
 } & Record<string, any>;
+
+export type JSONBlueprint = {
+  name: string;
+  version?: string;
+} & Record<string, any>;
+
+export type JSONMicrofrontend = {
+  baseName: string;
+};
+export type JSONGeneratorJhipsterContentDeployment = {
+  appsFolders?: string[];
+  clusteredDbApps?: string[];
+};
+
+export type AbstractJSONGeneratorJhipsterContent = {
+  baseName: string;
+  applicationType?: string;
+  entities?: string[];
+  jhipsterVersion?: string;
+  packageName?: string;
+  packageFolder?: string;
+  serverPort?: string;
+  authenticationType?: string;
+  buildTool?: string;
+  cacheProvider?: string;
+  clientPackageManager?: string;
+  creationTimestamp?: number;
+  databaseType?: string;
+  devDatabaseType?: string;
+  enableHibernateCache?: boolean;
+  enableTranslation?: boolean;
+  jhiPrefix?: string;
+  jwtSecretKey?: string;
+  languages?: string[];
+  messageBroker?: string;
+  nativeLanguage?: string;
+  prodDatabaseType?: string;
+  searchEngine?: string;
+  serviceDiscoveryType?: string;
+  skipClient?: boolean;
+  skipUserManagement?: boolean;
+  testFrameworks?: string[];
+  websocket?: string;
+} & JSONGeneratorJhipsterContentDeployment &
+  Record<string, any>;
+
+export type JSONGeneratorJhipsterContent = {
+  promptValues?: Partial<JSONGeneratorJhipsterContent>;
+  blueprints?: JSONBlueprint[] | null;
+  microfrontends?: JSONMicrofrontend[] | null;
+} & AbstractJSONGeneratorJhipsterContent;
+
+export type PostProcessedJSONGeneratorJhipsterContent = {
+  blueprints?: string[];
+  microfrontends?: string[];
+} & AbstractJSONGeneratorJhipsterContent;
+
+export type PostProcessedJSONRootObject = {
+  [GENERATOR_JHIPSTER]: PostProcessedJSONGeneratorJhipsterContent;
+};
+
+export type JHipsterYoRcContent = {
+  [GENERATOR_JHIPSTER]: JSONGeneratorJhipsterContent;
+};
+
+export type JHipsterYoRcContentWrapper = {
+  application?: PostProcessedJSONRootObject | JHipsterYoRcContent;
+};

package/dist/types/jdl/exporters/applications/jhipster-application-formatter.d.ts

@@ -16,17 +16,17 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import JDLApplication from '../../models/jdl-application.js';
+import { PostProcessedJDLJSONApplication } from '../types.js';
 /**
  * Exports JDL applications to JDL files in separate folders (based on application base names).
  * @param applications the applications to exporters (key: application name, value: a JDLApplication).
- * @param {Object} [configuration]
  * @return object[] exported applications in their final form.
  */
-export declare function formatApplicationsToExport(applications: any, configuration: any): any[];
+export declare function formatApplicationsToExport(applications: Record<string, JDLApplication>): PostProcessedJDLJSONApplication[];
 /**
  * Exports JDL a application to a JDL file in the current directory.
  * @param {Object} application - the JDL application to export.
- * @param {Object} [configuration]
  * @return {Object} the exported application in its final form.
  */
-export declare function formatApplicationToExport(application: any, configuration?: {}): any;
+export declare function formatApplicationToExport(application: JDLApplication): PostProcessedJDLJSONApplication;

package/dist/types/jdl/exporters/config.d.ts

@@ -1 +1,2 @@
-export declare const mergeYoRcContent: (oldConfig: Record<string, Record<string, any>>, newConfig: Record<string, Record<string, any>>) => Record<string, Record<string, any>>;
+import { JHipsterYoRcContent } from '../converters/types.js';
+export declare const mergeYoRcContent: (oldConfig: JHipsterYoRcContent, newConfig: JHipsterYoRcContent) => JHipsterYoRcContent;

package/dist/types/jdl/exporters/export-utils.d.ts

@@ -16,10 +16,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { JHipsterYoRcContent } from '../converters/types.js';
 export declare const GENERATOR_NAME = "generator-jhipster";
 /**
  * This function writes a Yeoman config file in the current folder.
  * @param config the configuration.
  * @param yoRcPath the yeoman conf file path
  */
-export declare function writeConfigFile(config: any, yoRcPath?: string): void;
+export declare function writeConfigFile(config: JHipsterYoRcContent, yoRcPath?: string): void;

package/dist/types/jdl/exporters/jdl-exporter.d.ts

@@ -16,10 +16,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import JDLObject from '../models/jdl-object.js';
 /**
  * Writes down the given JDL to a file.
  * @param jdl the JDL to write.
  * @param path the path where the file will be written.
  * @returns file contents
  */
-export default function exportToJDL(jdl: any, path?: string): string;
+export default function exportToJDL(jdl: JDLObject, path?: string): string;

package/dist/types/jdl/exporters/jhipster-deployment-exporter.d.ts

@@ -16,9 +16,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import JDLDeployment from '../models/jdl-deployment.js';
+import { JHipsterYoRcContent } from '../converters/types.js';
 /**
  * Exports JDL deployments to .yo-rc.json files in separate folders (based on deployment type).
  * @param deployments the deployments to exporters (key: deployment type, value: JDLDeployment- deployment config).
  * @return object[] exported deployments in their final form.
  */
-export default function exportDeployments(deployments: any): unknown[];
+export default function exportDeployments(deployments: Record<string, JDLDeployment>): Partial<JHipsterYoRcContent>[];

package/dist/types/jdl/exporters/jhipster-entity-exporter.d.ts

@@ -16,6 +16,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { JSONEntity } from '../converters/types.js';
+import { JhipsterJSONJDLExporterWrapper } from './types.js';
 /**
  * Exports the passed entities to JSON.
  * @param {Object} passedConfiguration - the object having the keys:
@@ -27,4 +29,4 @@
  * @param {String} passedConfiguration.application.type - the application's type.
  * @returns {Array<JSONEntity>} the exported entities.
  */
-export default function exportEntities(passedConfiguration: any): any;
+export default function exportEntities(passedConfiguration: JhipsterJSONJDLExporterWrapper): JSONEntity[];

package/dist/types/jdl/exporters/types.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Copyright 2013-2024 the original author or authors from the JHipster project.
+ *
+ * This file is part of the JHipster project, see https://www.jhipster.tech/
+ * for more information.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { GENERATOR_NAME } from './export-utils.js';
+import { JSONEntity } from '../converters/types.js';
+
+export type JDLJSONApplicationContent = {
+  entities?: string[];
+  creationTimestamp?: number;
+} & Record<string, any>;
+
+export type JDLJSONApplication = {
+  [GENERATOR_NAME]: JDLJSONApplicationContent;
+  namespaceConfigs: Record<string, Record<string, any>>;
+};
+
+export type JDLJSONBlueprint = {
+  name: string;
+};
+
+export type JDLJSONMicrofrontend = {
+  baseName: string;
+};
+
+export type PostProcessedJDLJSONApplication = {
+  blueprints: JDLJSONBlueprint[];
+  microfrontends: JDLJSONMicrofrontend[];
+} & JDLJSONApplication;
+
+export type RawJDLJSONApplication = {
+  entityNames?: string;
+  frontEndBuilder?: string;
+  blueprints?: string;
+  microfrontends?: string;
+} & JDLJSONApplication;
+
+export type JhipsterJSONJDLApplicationExporter = {
+  forSeveralApplications?: boolean;
+  name: string;
+  type: string;
+};
+
+export type JhipsterJSONJDLExporterWrapper = {
+  entities: JSONEntity[];
+  application: JhipsterJSONJDLApplicationExporter;
+};

package/dist/types/jdl/jhipster/binary-options.d.ts

@@ -12,7 +12,7 @@ declare const _default: {
         CLIENT_ROOT_FOLDER: string;
     };
     DefaultValues: {
-        [x: string]: string;
+        [x: string]: any;
     };
     OptionValues: {
         mapstruct: string;
@@ -24,42 +24,24 @@ declare const _default: {
         couchbase: string;
     };
     Values: {
-        [x: string]: {
+        dto: {
             MAPSTRUCT: string;
             NO: string;
-            SERVICE_CLASS?: undefined;
-            SERVICE_IMPL?: undefined;
-            PAGINATION?: undefined;
-            'INFINITE-SCROLL'?: undefined;
-            ELASTICSEARCH?: undefined;
-            COUCHBASE?: undefined;
-        } | {
+        };
+        service: {
             SERVICE_CLASS: string;
             SERVICE_IMPL: string;
             NO: string;
-            MAPSTRUCT?: undefined;
-            PAGINATION?: undefined;
-            'INFINITE-SCROLL'?: undefined;
-            ELASTICSEARCH?: undefined;
-            COUCHBASE?: undefined;
-        } | {
+        };
+        pagination: {
             PAGINATION: string;
             'INFINITE-SCROLL': string;
             NO: string;
-            MAPSTRUCT?: undefined;
-            SERVICE_CLASS?: undefined;
-            SERVICE_IMPL?: undefined;
-            ELASTICSEARCH?: undefined;
-            COUCHBASE?: undefined;
-        } | {
+        };
+        search: {
             ELASTICSEARCH: string;
             COUCHBASE: string;
             NO: string;
-            MAPSTRUCT?: undefined;
-            SERVICE_CLASS?: undefined;
-            SERVICE_IMPL?: undefined;
-            PAGINATION?: undefined;
-            'INFINITE-SCROLL'?: undefined;
         };
     };
     exists: typeof exists;

package/dist/types/jdl/jhipster/field-types.d.ts

@@ -85,5 +85,5 @@ declare const _default: {
 export default _default;
 export declare function isCommonDBType(type: any): boolean;
 export declare function isBlobType(type?: any): boolean;
-export declare function hasValidation(type: any, validation: any, isAnEnum?: any): any;
-export declare function getIsType(databaseType: any, callback?: any): any;
+export declare function hasValidation(type: any, validation: any, isAnEnum?: boolean): boolean;
+export declare function getIsType(databaseType?: string, callback?: any): (type: any) => boolean;

package/dist/types/jdl/jhipster/json-entity.d.ts

@@ -20,7 +20,7 @@
  * The JSONEntity class represents a read-to-be exported to JSON entity.
  */
 declare class JSONEntity {
-    annotations: Record<string, boolean | string | number>;
+    annotations: Record<string, boolean | string | number | undefined>;
     [x: string]: any;
     /**
      * Creates a new JSONEntity instance.
@@ -39,7 +39,7 @@ declare class JSONEntity {
      *        - fluentMethods, defaults to true,
      *        - clientRootFolder
      */
-    constructor(args: any);
+    constructor(args: Partial<JSONEntity>);
     addFields(fields: any): void;
     addField(field: any): void;
     addRelationships(relationships: any): void;

package/dist/types/jdl/models/abstract-jdl-option.d.ts

@@ -16,20 +16,25 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+export type JDLOptionParams = {
+    name: string;
+    entityNames?: Set<string> | string[];
+    excludedNames?: Set<string> | string[];
+};
 export default class AbstractJDLOption {
-    name: any;
+    name: string;
     entityNames: Set<string>;
-    excludedNames: any;
-    constructor(args: any);
-    addEntityName(entityName: any): false | Set<string>;
-    addEntitiesFromAnotherOption(option: any): boolean;
-    excludeEntityName(entityName: any): void;
-    getType(): void;
-    setEntityNames(newEntityNames: any): void;
+    excludedNames: Set<string>;
+    constructor(args: JDLOptionParams);
+    addEntityName(entityName: string): false | Set<string>;
+    addEntitiesFromAnotherOption(option?: AbstractJDLOption): boolean;
+    excludeEntityName(entityName: string): void;
+    getType(): string;
+    setEntityNames(newEntityNames: Iterable<string>): void;
     /**
      * Resolves the option's list of entity names (without '*' and taking into account the excluded names).
      * @param entityNames all the entity names declared in a JDL Object.
      * @returns the resolved list.
      */
-    resolveEntityNames(entityNames: string[]): Set<string>;
+    resolveEntityNames(entityNames: string[] | undefined): Set<string>;
 }

package/dist/types/jdl/models/boolean-jdl-application-configuration-option.d.ts

@@ -17,5 +17,5 @@
  * limitations under the License.
  */
 import JDLApplicationConfigurationOption from './jdl-application-configuration-option.js';
-export default class BooleanJDLApplicationConfigurationOption extends JDLApplicationConfigurationOption {
+export default class BooleanJDLApplicationConfigurationOption extends JDLApplicationConfigurationOption<boolean> {
 }

package/dist/types/jdl/models/integer-jdl-application-configuration-option.d.ts

@@ -17,5 +17,5 @@
  * limitations under the License.
  */
 import JDLApplicationConfigurationOption from './jdl-application-configuration-option.js';
-export default class IntegerJDLApplicationConfigurationOption extends JDLApplicationConfigurationOption {
+export default class IntegerJDLApplicationConfigurationOption extends JDLApplicationConfigurationOption<number> {
 }

package/dist/types/jdl/models/jdl-application-configuration-factory.d.ts

@@ -18,4 +18,4 @@
  */
 import JDLApplicationConfiguration from './jdl-application-configuration.js';
 export default function createApplicationConfigurationFromObject(configurationObject?: {}): JDLApplicationConfiguration;
-export declare function createApplicationNamespaceConfigurationFromObject(parsedNamespaceConfigs?: Record<string, Record<string, any>>): Array<JDLApplicationConfiguration>;
+export declare function createApplicationNamespaceConfigurationFromObject(parsedNamespaceConfigs?: Record<string, Record<string, boolean | number | string[] | string>>): Array<JDLApplicationConfiguration>;

package/dist/types/jdl/models/jdl-application-configuration-option.d.ts

@@ -16,15 +16,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export default class JDLApplicationConfigurationOption {
+export default class JDLApplicationConfigurationOption<T> {
     name: string;
-    value: any;
+    value: T;
     /**
      * Creates a new application option.
      * @param {String} name - the option's name.
      * @param {any} value - the option's value, can be virtually anything: a String, an Int, a boolean...
      */
-    constructor(name: string, value: any);
-    getValue(): any;
+    constructor(name: string, value: T);
+    getValue(): T;
     toString(): string;
 }

package/dist/types/jdl/models/jdl-application-configuration.d.ts

@@ -18,12 +18,12 @@
  */
 import JDLApplicationConfigurationOption from './jdl-application-configuration-option.js';
 export default class JDLApplicationConfiguration {
-    options: Record<string, JDLApplicationConfigurationOption>;
+    options: Record<string, JDLApplicationConfigurationOption<any>>;
     namespace?: string;
     constructor(namespace?: string);
     hasOption(optionName: string): boolean;
-    getOption(optionName: string): JDLApplicationConfigurationOption | undefined;
-    setOption(option: JDLApplicationConfigurationOption): void;
-    forEachOption(passedFunction: (option: JDLApplicationConfigurationOption) => void): void;
+    getOption(optionName: string): JDLApplicationConfigurationOption<any> | undefined;
+    setOption(option: JDLApplicationConfigurationOption<any>): void;
+    forEachOption(passedFunction: (option: JDLApplicationConfigurationOption<any>) => void): void;
     toString(indent?: number): string;
 }

package/dist/types/jdl/models/jdl-application-definition.d.ts

@@ -1,5 +1,5 @@
 export type JDLApplicationOptionValue = string | number | boolean | undefined | never[] | Record<string, string>;
-export type JDLApplicationOptionTypeValue = 'string' | 'integer' | 'boolean' | 'list';
+export type JDLApplicationOptionTypeValue = 'string' | 'integer' | 'boolean' | 'list' | 'quotedList';
 export type JDLApplicationOptionType = {
     type: JDLApplicationOptionTypeValue;
 };
@@ -19,18 +19,18 @@ export default class JDLApplicationDefinition {
      * @param {String|Boolean|Number} value - the option value.
      * @returns {Boolean} whether the option value exists for the name.
      */
-    doesOptionValueExist(name: any, value: any): boolean;
+    doesOptionValueExist(name: string, value: string): boolean;
     /**
      * Checks whether the option's exists.
      * @param {String} optionName - the option's name.
      * @returns {Boolean} the option's existence.
      */
-    doesOptionExist(optionName: any): boolean;
+    doesOptionExist(optionName: string): boolean;
     /**
      * Checks whether the corresponding option has a value that should be quoted in the JDL, like the jhipsterVersion
      * attribute.
      * @param {String} optionName - the name of the option to check.
      * @return {boolean} whether it should be quoted in the JDL.
      */
-    shouldTheValueBeQuoted(optionName: any): boolean;
+    shouldTheValueBeQuoted(optionName: string): boolean;
 }

package/dist/types/jdl/models/jdl-application-entities.d.ts

@@ -23,10 +23,10 @@ export default class JDLApplicationEntities {
      * @param entityNames - the entity names.
      */
     constructor(entityNames?: string[]);
-    add(entityName: any): void;
-    addEntityNames(entityNames?: never[]): void;
-    has(entityName: any): boolean;
-    forEach(passedFunction: any): void;
+    add(entityName: string): void;
+    addEntityNames(entityNames?: string[]): void;
+    has(entityName: string): boolean;
+    forEach(passedFunction: (name: string) => void): void;
     toArray(): string[];
     size(): number;
     toString(indent?: number): string;

package/dist/types/jdl/models/jdl-application.d.ts

@@ -18,24 +18,27 @@
  */
 import JDLApplicationConfigurationOption from './jdl-application-configuration-option.js';
 import JDLApplicationConfiguration from './jdl-application-configuration.js';
+import JDLApplicationEntities from './jdl-application-entities.js';
+import JDLOptions from './jdl-options.js';
+import AbstractJDLOption from './abstract-jdl-option.js';
 export default class JDLApplication {
     config: JDLApplicationConfiguration;
     namespaceConfigs: Array<JDLApplicationConfiguration>;
-    entityNames: any;
-    options: any;
+    entityNames: JDLApplicationEntities;
+    options: JDLOptions;
     constructor({ config, entityNames, namespaceConfigs }?: any);
-    setConfigurationOption(option: any): void;
-    hasConfigurationOption(optionName: any): boolean;
-    getConfigurationOptionValue(optionName: any): any;
-    forEachConfigurationOption(passedFunction: (option: JDLApplicationConfigurationOption) => void): void;
+    setConfigurationOption(option: JDLApplicationConfigurationOption<any>): void;
+    hasConfigurationOption(optionName: string): boolean;
+    getConfigurationOptionValue(optionName: string): any;
+    forEachConfigurationOption(passedFunction: (option: JDLApplicationConfigurationOption<any>) => void): void;
     forEachNamespaceConfiguration(passedFunction: (option: JDLApplicationConfiguration) => void): void;
-    addEntityName(entityName: any): void;
-    addEntityNames(entityNames?: any): void;
-    getEntityNames(): any;
-    hasEntityName(entityName: any): any;
+    addEntityName(entityName: string): void;
+    addEntityNames(entityNames?: string[]): void;
+    getEntityNames(): string[];
+    hasEntityName(entityName: string): boolean;
     forEachEntityName(passedFunction: any): void;
-    addOption(jdlOption: any): void;
-    forEachOption(passedFunction: any): void;
-    getOptionQuantity(): any;
+    addOption(jdlOption: AbstractJDLOption | undefined): void;
+    forEachOption(passedFunction: (option: AbstractJDLOption) => void): void;
+    getOptionQuantity(): number;
     toString(): string;
 }

package/dist/types/jdl/models/jdl-binary-option.d.ts

@@ -16,13 +16,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import AbstractJDLOption from './abstract-jdl-option.js';
+import AbstractJDLOption, { JDLOptionParams } from './abstract-jdl-option.js';
 /**
  * For options like the DTO, the service, etc.
  */
 export default class JDLBinaryOption extends AbstractJDLOption {
-    value: any;
-    constructor(args: any);
+    value: string;
+    constructor(args: JDLOptionParams & {
+        value: string;
+    });
     getType(): string;
     toString(): string;
 }

package/dist/types/jdl/models/jdl-deployment.d.ts

@@ -1,4 +1,16 @@
+import { ParsedJDLDeployment } from '../converters/parsed-jdl-to-jdl-object/types.js';
 export default class JDLDeployment {
-    constructor(args: any);
+    deploymentType: string;
+    appsFolders?: string[];
+    directoryPath?: string;
+    gatewayType?: string;
+    kubernetesServiceType?: string;
+    istio?: boolean;
+    ingressDomain?: string;
+    ingressType?: string;
+    storageType?: string;
+    monitoring?: string;
+    clusteredDbApps?: string[];
+    constructor(args: ParsedJDLDeployment);
     toString(): string;
 }

package/dist/types/jdl/models/jdl-entity.d.ts

@@ -18,12 +18,12 @@
  */
 import JDLField from './jdl-field.js';
 export default class JDLEntity {
-    name: any;
-    tableName: any;
+    name: string;
+    tableName: string | undefined;
     fields: Record<string, JDLField>;
-    comment: any;
-    annotations: Record<string, boolean | string | number>;
-    constructor(args: any);
+    comment: string | undefined;
+    annotations: Record<string, boolean | string | number | undefined>;
+    constructor(args: Partial<JDLEntity>);
     /**
      * Adds the fields to the entity.
      * @param fields - the fields to add

package/dist/types/jdl/models/jdl-enum-value.d.ts

@@ -1,7 +1,7 @@
 export default class JDLEnumValue {
-    name: any;
-    value: any;
-    comment: any;
-    constructor(name: any, value: any, comment: any);
+    name: string;
+    value?: string;
+    comment?: string;
+    constructor(name: string, value?: string, comment?: string);
     toString(): string;
 }

package/dist/types/jdl/models/jdl-enum.d.ts

@@ -16,12 +16,16 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import JDLEnumValue from './jdl-enum-value.js';
+import { ParsedJDLEnumValue } from '../converters/parsed-jdl-to-jdl-object/types.js';
 export default class JDLEnum {
-    comment: any;
-    name: any;
-    values: Map<any, any>;
-    constructor(args: any);
+    comment?: string;
+    name: string;
+    values: Map<string, JDLEnumValue>;
+    constructor(args: Partial<Omit<JDLEnum, 'values'> & {
+        values: ParsedJDLEnumValue[];
+    }>);
     getValuesAsString(): string;
-    getValueJavadocs(): {};
+    getValueJavadocs(): Record<string, string>;
     toString(): string;
 }