hekireki 0.0.1

package/dist/generator/mermaid/generator/generate-er-content.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateERContent = generateERContent;
+const __1 = require("..");
+const extract_relations_1 = require("../validator/extract-relations");
+const generate_model_info_1 = require("../generator/generate-model-info");
+const remove_duplicate_relations_1 = require("../validator/remove-duplicate-relations");
+/**
+ * generate ER content
+ * @function generateERContent
+ * @param models
+ * @returns ER content
+ */
+function generateERContent(models) {
+    // extract all relations
+    const allRelations = models.flatMap(extract_relations_1.extractRelations);
+    // remove duplicate relations
+    const uniqueRelations = (0, remove_duplicate_relations_1.removeDuplicateRelations)(allRelations);
+    // collect all model info
+    const modelInfos = models.flatMap(generate_model_info_1.generateModelInfo);
+    // build ER diagram
+    return [...__1.ER_HEADER, ...uniqueRelations, ...modelInfos, ...__1.ER_FOOTER];
+}

package/dist/generator/mermaid/generator/generate-model-fields.d.ts

@@ -0,0 +1,8 @@
+import type { DMMF } from "@prisma/generator-helper";
+/**
+ * generate model fields
+ * @function generateModelFields
+ * @param model
+ * @returns
+ */
+export declare function generateModelFields(model: DMMF.Model): string[];

package/dist/generator/mermaid/generator/generate-model-fields.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateModelFields = generateModelFields;
+const ZOD_ANNOTATION = "@z.";
+const VALIBOT_ANNOTATION = "@v.";
+/**
+ * generate model fields
+ * @function generateModelFields
+ * @param model
+ * @returns
+ */
+function generateModelFields(model) {
+    return model.fields
+        .map((field) => {
+        if (field.relationName) {
+            return null;
+        }
+        const commentPart = field.documentation
+            ? field.documentation
+                .split("\n")
+                .filter((line) => !(line.includes(ZOD_ANNOTATION) ||
+                line.includes(VALIBOT_ANNOTATION)))
+                .join("\n")
+                .trim()
+            : "";
+        return `        ${field.type} ${field.name} ${commentPart ? `"${commentPart}"` : ""}`;
+    })
+        .filter((field) => field !== null);
+}

package/dist/generator/mermaid/generator/generate-model-info.d.ts

@@ -0,0 +1,8 @@
+import type { Model } from "../type";
+/**
+ * generate model info
+ * @function generateModelInfo
+ * @param model
+ * @returns
+ */
+export declare function generateModelInfo(model: Model): readonly string[];

package/dist/generator/mermaid/generator/generate-model-info.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateModelInfo = generateModelInfo;
+const generate_model_fields_1 = require("./generate-model-fields");
+/**
+ * generate model info
+ * @function generateModelInfo
+ * @param model
+ * @returns
+ */
+function generateModelInfo(model) {
+    return [
+        `    ${model.name} {`,
+        ...(0, generate_model_fields_1.generateModelFields)(model),
+        "    }",
+    ];
+}

package/dist/generator/mermaid/generator/generate-relation-line.d.ts

@@ -0,0 +1,8 @@
+import type { Relation } from "../type";
+/**
+ * generate relation line
+ * @function generateRelationLine
+ * @param relation
+ * @returns string
+ */
+export declare function generateRelationLine(relation: Relation): string;

package/dist/generator/mermaid/generator/generate-relation-line.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRelationLine = generateRelationLine;
+const __1 = require("..");
+/**
+ * generate relation line
+ * @function generateRelationLine
+ * @param relation
+ * @returns string
+ */
+function generateRelationLine(relation) {
+    const cardinality = __1.CARDINALITY_MAP[relation.type];
+    if (!cardinality) {
+        throw new Error(`Unknown relation type: ${relation.type}`);
+    }
+    return `    ${relation.fromModel} ${cardinality} ${relation.toModel} : "(${relation.fromField}) - (${relation.toField})"`;
+}

package/dist/generator/mermaid/index.d.ts

@@ -0,0 +1,10 @@
+import type { GeneratorOptions } from "@prisma/generator-helper";
+import type { RelationType } from "./type";
+export type Config = {
+    output?: string;
+    file?: string | string[];
+};
+export declare const CARDINALITY_MAP: Record<RelationType, string>;
+export declare const ER_HEADER: readonly ["```mermaid", "erDiagram"];
+export declare const ER_FOOTER: readonly ["```"];
+export declare function main(options: GeneratorOptions): Promise<void>;

package/dist/generator/mermaid/index.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ER_FOOTER = exports.ER_HEADER = exports.CARDINALITY_MAP = void 0;
+exports.main = main;
+const output_1 = require("./output");
+const generator_helper_1 = require("@prisma/generator-helper");
+const generate_er_content_1 = require("./generator/generate-er-content");
+const DEFAULT_CONFIG = {
+    output: "./mermaid-er",
+    file: "ER.md",
+};
+exports.CARDINALITY_MAP = {
+    // Required Relationships
+    // Both sides required (one-to-one)
+    "one-to-one": "||--||", // 1 --- 1
+    // One side singular, the other multiple
+    "one-to-many": "||--o{", // 1 --- * (also known as one-to-zero-many)
+    "many-to-one": "}o--||", // * --- 1
+    // Both sides multiple (many-to-many)
+    "many-to-many": "}o--o{", // * --- *
+    // One side required, one side optional (0..1)
+    "one-to-zero-one": "||--o|", // 1 --- 0..1
+    "zero-one-to-one": "o|--||", // 0..1 --- 1
+    // Both sides optional singular (0..1 on both sides)
+    "zero-to-one": "o|--o|", // 0..1 --- 0..1
+    "zero-to-zero-one": "o|--o|", // Alias for zero-to-one
+    // One side optional singular, the other multiple
+    "zero-to-many": "o|--o{", // 0 --- *
+    "zero-one-to-many": "o|--o{", // 0..1 --- *
+    "many-to-zero-one": "}o--o|", // * --- 0..1
+    // Optional Relationships (using dotted lines)
+    "one-to-one-optional": "||..||", // 1..1
+    "one-to-many-optional": "||..o{", // 1..*
+    "many-to-one-optional": "}o..||", // *..1
+    "many-to-many-optional": "}o..o{", // *..*
+    "one-to-zero-one-optional": "||..o|", // 1..0..1
+    "zero-one-to-one-optional": "o|..||", // 0..1..1
+    "zero-to-one-optional": "o|..o|", // 0..1 (both sides optional singular)
+    "zero-to-many-optional": "o|..o{", // 0..* (optional multiple)
+    "zero-one-to-many-optional": "o|..o{", // 0..1 --- * (optional)
+    "many-to-zero-one-optional": "}o..o|", // *..0..1
+    // Nuanced Patterns (Aliases)
+    "many-to-zero-many": "}o..o{", // * --- 0..* (equivalent to many-to-many-optional)
+    "zero-many-to-many": "o{..}o", // 0..* --- * (left side optional multiple, right side required multiple)
+    "zero-many-to-zero-many": "o{..o{", // both sides optional multiple
+};
+// ER diagram header
+exports.ER_HEADER = ["```mermaid", "erDiagram"];
+// ER diagram footer
+exports.ER_FOOTER = ["```"];
+// main function
+async function main(options) {
+    const config = {
+        output: options.generator.output?.value ?? DEFAULT_CONFIG.output,
+        file: options.generator.config?.file ?? DEFAULT_CONFIG.file,
+    };
+    const models = options.dmmf.datamodel.models;
+    const content = (0, generate_er_content_1.generateERContent)(models);
+    if (!config.output) {
+        throw new Error("output is required");
+    }
+    (0, output_1.OutputFile)(content, config);
+}
+// prisma generator handler
+(0, generator_helper_1.generatorHandler)({
+    onManifest() {
+        return {
+            defaultOutput: "./mermaid-er",
+            prettyName: "ekireki-ER",
+        };
+    },
+    onGenerate: main,
+});

package/dist/generator/mermaid/output/index.d.ts

@@ -0,0 +1,8 @@
+import type { Config } from "..";
+import type { ERContent } from "../type";
+/**
+ * Output the ER content to a file
+ * @param content - The ER content
+ * @param config - The configuration
+ */
+export declare function OutputFile(content: ERContent, config: Config): void;

package/dist/generator/mermaid/output/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutputFile = OutputFile;
+const node_fs_1 = __importDefault(require("node:fs"));
+/**
+ * Output the ER content to a file
+ * @param content - The ER content
+ * @param config - The configuration
+ */
+function OutputFile(content, config) {
+    const outputDir = config.output;
+    if (!outputDir) {
+        throw new Error("output is required");
+    }
+    if (!node_fs_1.default.existsSync(outputDir)) {
+        node_fs_1.default.mkdirSync(outputDir, { recursive: true });
+    }
+    const file = config.file ?? "ER.md";
+    const filePath = `${outputDir}/${file}`;
+    node_fs_1.default.writeFileSync(filePath, content.join("\n"), { encoding: "utf-8" });
+}

package/dist/generator/mermaid/type/index.d.ts

@@ -0,0 +1,11 @@
+import type { DMMF } from "@prisma/generator-helper";
+export type RelationType = "one-to-one" | "one-to-many" | "many-to-one" | "many-to-many" | "one-to-zero-one" | "zero-one-to-one" | "zero-to-one" | "zero-to-zero-one" | "zero-to-many" | "zero-one-to-many" | "many-to-zero-one" | "one-to-one-optional" | "one-to-many-optional" | "many-to-one-optional" | "many-to-many-optional" | "one-to-zero-one-optional" | "zero-one-to-one-optional" | "zero-to-one-optional" | "zero-to-many-optional" | "zero-one-to-many-optional" | "many-to-zero-one-optional" | "many-to-zero-many" | "zero-many-to-many" | "zero-many-to-zero-many";
+export type Relation = {
+    fromModel: string;
+    toModel: string;
+    fromField: string;
+    toField: string;
+    type: RelationType;
+};
+export type Model = Readonly<DMMF.Model>;
+export type ERContent = readonly string[];

package/dist/generator/mermaid/type/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/generator/mermaid/validator/exclude-many-to-one-relations.d.ts

@@ -0,0 +1,7 @@
+/**
+ * exclude many-to-one relations
+ * @function excludeManyToOneRelations
+ * @param relations
+ * @returns
+ */
+export declare function excludeManyToOneRelations(relations: readonly string[]): readonly string[];

package/dist/generator/mermaid/validator/exclude-many-to-one-relations.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.excludeManyToOneRelations = excludeManyToOneRelations;
+/**
+ * exclude many-to-one relations
+ * @function excludeManyToOneRelations
+ * @param relations
+ * @returns
+ */
+function excludeManyToOneRelations(relations) {
+    return [...new Set(relations)].filter((r) => !r.includes("many-to-one"));
+}

package/dist/generator/mermaid/validator/extract-relations.d.ts

@@ -0,0 +1,8 @@
+import type { Model } from "../type";
+/**
+ * extract relations from model
+ * @function extractRelations
+ * @param model
+ * @returns
+ */
+export declare function extractRelations(model: Model): readonly string[];

package/dist/generator/mermaid/validator/extract-relations.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractRelations = extractRelations;
+const generate_relation_line_1 = require("../generator/generate-relation-line");
+const parse_relation_1 = require("./parse-relation");
+/**
+ * extract relations from model
+ * @function extractRelations
+ * @param model
+ * @returns
+ */
+function extractRelations(model) {
+    const relations = [];
+    // @r annotation
+    if (model.documentation) {
+        const annotationRelations = model.documentation
+            .split("\n")
+            .map((line) => {
+            const relation = (0, parse_relation_1.parseRelation)(line);
+            return relation ? (0, generate_relation_line_1.generateRelationLine)(relation) : null;
+        })
+            .filter((line) => line !== null);
+        relations.push(...annotationRelations);
+    }
+    return relations;
+}

package/dist/generator/mermaid/validator/is-relation.d.ts

@@ -0,0 +1,2 @@
+import type { RelationType } from "../type";
+export declare function isRelation(value: unknown): value is RelationType;

package/dist/generator/mermaid/validator/is-relation.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRelation = isRelation;
+const VALID_RELATIONS = new Set([
+    "one-to-one",
+    "one-to-many",
+    "many-to-one",
+    "many-to-many",
+    "one-to-zero-one",
+    "zero-one-to-one",
+    "zero-to-one",
+    "zero-to-zero-one",
+    "zero-to-many",
+    "zero-one-to-many",
+    "many-to-zero-one",
+    "one-to-one-optional",
+    "one-to-many-optional",
+    "many-to-one-optional",
+    "many-to-many-optional",
+    "one-to-zero-one-optional",
+    "zero-one-to-one-optional",
+    "zero-to-one-optional",
+    "zero-to-many-optional",
+    "zero-one-to-many-optional",
+    "many-to-zero-one-optional",
+    "many-to-zero-many",
+    "zero-many-to-many",
+    "zero-many-to-zero-many",
+]);
+function isRelation(value) {
+    return typeof value === "string" && VALID_RELATIONS.has(value);
+}

package/dist/generator/mermaid/validator/parse-relation.d.ts

@@ -0,0 +1,8 @@
+import type { Relation } from "../type";
+/**
+ * parse relation
+ * @function parseRelation
+ * @param line
+ * @returns
+ */
+export declare function parseRelation(line: string): Relation | null;

package/dist/generator/mermaid/validator/parse-relation.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRelation = parseRelation;
+const is_relation_1 = require("./is-relation");
+/**
+ * parse relation
+ * @function parseRelation
+ * @param line
+ * @returns
+ */
+function parseRelation(line) {
+    const relationRegex = /^@relation\s+(\w+)\.(\w+)\s+(\w+)\.(\w+)\s+(\w+-to-\w+)$/;
+    const match = line.trim().match(relationRegex);
+    if (!match) {
+        return null;
+    }
+    const [, fromModel, fromField, toModel, toField, relationType] = match;
+    if (!(0, is_relation_1.isRelation)(relationType)) {
+        return null;
+    }
+    return {
+        fromModel,
+        fromField,
+        toModel,
+        toField,
+        type: relationType,
+    };
+}

package/dist/generator/mermaid/validator/remove-duplicate-relations.d.ts

@@ -0,0 +1,7 @@
+/**
+ * remove duplicate relations
+ * @function removeDuplicateRelations
+ * @param relations
+ * @returns
+ */
+export declare function removeDuplicateRelations(relations: readonly string[]): readonly string[];

package/dist/generator/mermaid/validator/remove-duplicate-relations.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeDuplicateRelations = removeDuplicateRelations;
+/**
+ * remove duplicate relations
+ * @function removeDuplicateRelations
+ * @param relations
+ * @returns
+ */
+function removeDuplicateRelations(relations) {
+    return [...new Set(relations)];
+}

package/dist/generator/valibot/generator/generate-valibot-infer-input.d.ts

@@ -0,0 +1,8 @@
+import type { Config } from "..";
+/**
+ * Generate the infer input type for the model
+ * @param modelName - The name of the model
+ * @param config - The configuration for the generator
+ * @returns The generated infer input type
+ */
+export declare function generateValibotInferInput(modelName: string, config: Config): string;

package/dist/generator/valibot/generator/generate-valibot-infer-input.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateValibotInferInput = generateValibotInferInput;
+const get_variable_name_helper_1 = require("../../../common/helper/get-variable-name-helper");
+const get_variable_schema_name_helper_1 = require("../../../common/helper/get-variable-schema-name-helper");
+/**
+ * Generate the infer input type for the model
+ * @param modelName - The name of the model
+ * @param config - The configuration for the generator
+ * @returns The generated infer input type
+ */
+function generateValibotInferInput(modelName, config) {
+    const typeName = (0, get_variable_name_helper_1.getVariableNameHelper)(modelName, config);
+    const schemaName = (0, get_variable_schema_name_helper_1.getVariableSchemaNameHelper)(modelName, config);
+    return `export type ${typeName} = v.InferInput<typeof ${schemaName}>`;
+}

package/dist/generator/valibot/generator/generate-valibot-properties.d.ts

@@ -0,0 +1,8 @@
+import type { Config } from "..";
+export declare function generateValibotProperties(modelFields: {
+    documentation: string;
+    modelName: string;
+    fieldName: string;
+    validation: string | null;
+    comment: string[];
+}[], config?: Config): string;

package/dist/generator/valibot/generator/generate-valibot-properties.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateValibotProperties = generateValibotProperties;
+function generateValibotProperties(modelFields, config) {
+    const fields = modelFields
+        .filter((field) => field.validation)
+        .map((field) => {
+        // @relation, @v, @z exclude
+        const cleanDoc = field.comment
+            .filter((line) => !(line.includes("@relation") ||
+            line.includes("@v") ||
+            line.includes("@z")))
+            .join("\n")
+            .trim();
+        const docComment = config?.comment && cleanDoc ? `  /**\n   * ${cleanDoc}\n   */\n` : "";
+        return `${docComment}  ${field.fieldName}: v.${field.validation}`;
+    })
+        .join(",\n");
+    return fields;
+}

package/dist/generator/valibot/generator/generate-valibot-schema.d.ts

@@ -0,0 +1,9 @@
+import type { Config } from "..";
+/**
+ * Generate Valibot schema
+ * @param modelName - The name of the model
+ * @param fields - The fields of the model
+ * @param config - The configuration for the generator
+ * @returns The generated Valibot schema
+ */
+export declare function generateValibotSchema(modelName: string, fields: string, config: Config): string;

package/dist/generator/valibot/generator/generate-valibot-schema.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateValibotSchema = generateValibotSchema;
+const get_variable_schema_name_helper_1 = require("../../../common/helper/get-variable-schema-name-helper");
+/**
+ * Generate Valibot schema
+ * @param modelName - The name of the model
+ * @param fields - The fields of the model
+ * @param config - The configuration for the generator
+ * @returns The generated Valibot schema
+ */
+function generateValibotSchema(modelName, fields, config) {
+    const schemaName = (0, get_variable_schema_name_helper_1.getVariableSchemaNameHelper)(modelName, config);
+    return `export const ${schemaName} = v.object({\n${fields}\n})`;
+}

package/dist/generator/valibot/generator/generate-valibot-schemas.d.ts

@@ -0,0 +1,15 @@
+import type { Config } from "..";
+/**
+ * generate valibot schemas
+ * @function generateValibotSchemas
+ * @param modelFields
+ * @param config
+ * @returns
+ */
+export declare function generateValibotSchemas(modelFields: {
+    documentation: string;
+    modelName: string;
+    fieldName: string;
+    validation: string | null;
+    comment: string[];
+}[], config: Config): string;

package/dist/generator/valibot/generator/generate-valibot-schemas.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateValibotSchemas = generateValibotSchemas;
+const generate_valibot_properties_1 = require("./generate-valibot-properties");
+const generate_valibot_schema_1 = require("./generate-valibot-schema");
+/**
+ * generate valibot schemas
+ * @function generateValibotSchemas
+ * @param modelFields
+ * @param config
+ * @returns
+ */
+function generateValibotSchemas(modelFields, config) {
+    const modelName = modelFields[0].modelName;
+    const modelDoc = modelFields[0].documentation || "";
+    const fields = (0, generate_valibot_properties_1.generateValibotProperties)(modelFields, config);
+    if (!(modelDoc || !config?.comment)) {
+        return (0, generate_valibot_schema_1.generateValibotSchema)(modelName, fields, config);
+    }
+    return `${(0, generate_valibot_schema_1.generateValibotSchema)(modelName, fields, config)}`;
+}

package/dist/generator/valibot/generator/generate-valibot.d.ts

@@ -0,0 +1,9 @@
+import type { Config } from "..";
+import type { Model } from "../../../common/type";
+/**
+ * Generate Valibot schemas and types
+ * @param models - The models to generate the Valibot schemas and types for
+ * @param config - The configuration for the generator
+ * @returns The generated Valibot schemas and types
+ */
+export declare function generateValibot(models: readonly Model[], config: Config): string;

package/dist/generator/valibot/generator/generate-valibot.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateValibot = generateValibot;
+const is_valibot_documentation_1 = require("../validator/is-valibot-documentation");
+const is_valibot_validation_1 = require("../validator/is-valibot-validation");
+const is_fields_validation_1 = require("../../../common/validator/is-fields-validation");
+const group_by_model_helper_1 = require("../../../common/helper/group-by-model-helper");
+const generate_valibot_schemas_1 = require("./generate-valibot-schemas");
+const generate_valibot_infer_input_1 = require("./generate-valibot-infer-input");
+const VALIBOT_IMPORT = `import * as v from 'valibot'\n`;
+/**
+ * Generate Valibot schemas and types
+ * @param models - The models to generate the Valibot schemas and types for
+ * @param config - The configuration for the generator
+ * @returns The generated Valibot schemas and types
+ */
+function generateValibot(models, config) {
+    const modelInfos = models.map((model) => {
+        return {
+            documentation: model.documentation ?? "",
+            name: model.name,
+            fields: model.fields,
+        };
+    });
+    const modelFields = modelInfos.map((model) => {
+        const fields = model.fields.map((field) => ({
+            documentation: model.documentation,
+            modelName: model.name,
+            fieldName: field.name,
+            comment: (0, is_valibot_documentation_1.isValibotDocumentValidation)(field.documentation),
+            validation: (0, is_valibot_validation_1.isValibotValidation)(field.documentation),
+        }));
+        return fields;
+    });
+    // null exclude
+    const validFields = (0, is_fields_validation_1.isFieldsValidation)(modelFields);
+    // group by model
+    const groupedByModel = (0, group_by_model_helper_1.groupByModelHelper)(validFields);
+    const valibots = Object.values(groupedByModel).map((fields) => {
+        return {
+            generateValibotSchema: (0, generate_valibot_schemas_1.generateValibotSchemas)(fields, config),
+            generateValibotInfer: config.type === "true"
+                ? (0, generate_valibot_infer_input_1.generateValibotInferInput)(fields[0].modelName, config)
+                : "",
+        };
+    });
+    return [
+        VALIBOT_IMPORT,
+        "",
+        valibots
+            .flatMap(({ generateValibotSchema, generateValibotInfer }) => [generateValibotSchema, generateValibotInfer].filter(Boolean))
+            .join("\n\n"),
+    ].join("\n");
+}

package/dist/generator/valibot/index.d.ts

@@ -0,0 +1,10 @@
+import type { GeneratorOptions } from "@prisma/generator-helper";
+export type Config = {
+    output?: string;
+    file?: string | string[];
+    schemaName?: "PascalCase" | "camelCase" | string | string[];
+    typeName?: "PascalCase" | "camelCase" | string | string[];
+    type?: boolean | string | string[];
+    comment?: boolean | string | string[];
+};
+export declare function main(options: GeneratorOptions): Promise<void>;