@tommasomeli/prisma-generator-nestjs-dto 0.1.3

package/dist/index.d.ts

@@ -0,0 +1,562 @@
+import { GeneratorOptions as GeneratorOptions$1 } from '@prisma/generator-helper';
+
+type NamingStrategy = 'camel' | 'snake' | 'kebab';
+type OutputType = 'class' | 'interface';
+type OutputStructure = 'nestjs' | 'flat';
+type File = {
+    path: string;
+    content: string;
+};
+type Annotation = {
+    name: string;
+    params: any;
+};
+/**
+ * Pipeline-internal field representation. Mirrors the relevant subset of
+ * `DMMF.Field` plus parsed annotations. We deliberately do not extend the
+ * Prisma DMMF type because newer versions are deeply readonly and that
+ * conflicts with the mutation patterns of sub-generators.
+ */
+type Field = {
+    name: string;
+    type: string;
+    kind?: 'scalar' | 'object' | 'enum' | 'unsupported';
+    isList: boolean;
+    isRequired: boolean;
+    isUnique: boolean;
+    isId: boolean;
+    isReadOnly: boolean;
+    isGenerated?: boolean;
+    isUpdatedAt?: boolean;
+    hasDefaultValue: boolean;
+    default?: any;
+    relationName?: string;
+    relationFromFields?: readonly string[] | string[];
+    relationToFields?: readonly string[] | string[];
+    relationOnDelete?: string;
+    documentation?: string | null;
+    annotations: Annotation[];
+    isNullable?: boolean;
+};
+/** Pipeline-internal model representation. See `Field` for rationale. */
+type Model = {
+    name: string;
+    dbName?: string | null;
+    fields: Field[];
+    documentation?: string | null;
+    primaryKey?: any;
+    uniqueFields?: readonly (readonly string[])[] | string[][];
+    uniqueIndexes?: any;
+    isGenerated?: boolean;
+    annotations: Annotation[];
+    outputType?: OutputType;
+};
+/**
+ * Override descriptor for a single Prisma scalar (`String`, `Int`, `Decimal`, ...).
+ * Applied by the built-in DTO generators when rendering field types, Swagger
+ * `@ApiProperty({ type })`, and Swagger `format`. `from` is automatically emitted
+ * as a top-level import in every file that references the overridden type.
+ *
+ * @example
+ * ```ts
+ * extraScalars: {
+ *   Decimal: { ts: 'Decimal', from: 'decimal.js' },
+ *   Json:    { ts: 'MyJson', from: 'src/json', apiType: 'Object' }
+ * }
+ * ```
+ */
+type ScalarOverride = {
+    /** TypeScript type used in field declarations (`field: ts;`). */
+    ts: string;
+    /** Module specifier the `ts` symbol is imported from. Omit for ambient/global types. */
+    from?: string;
+    /** TypeScript expression used in `@ApiProperty({ type: ... })`. Defaults to `ts`. */
+    apiType?: string;
+    /** Value passed to `@ApiProperty({ format })`. Omit to inherit / drop the default. */
+    format?: string;
+};
+/** Enriched config exposed to sub-generators after parsing the raw Prisma config. */
+type GeneratorConfig = {
+    provider: string;
+    output: string;
+    outputType: OutputType;
+    outputStructure: OutputStructure;
+    reExport: boolean;
+    fileNamingStrategy: NamingStrategy;
+    classValidator: boolean;
+    swaggerDocs: boolean;
+    prettier: boolean;
+    schemaDir?: string;
+    emitManifest: boolean;
+    extraDecorators: ImportType[];
+    extraValidators: ImportType[];
+    extraImports: ImportType[];
+    extraGenerators?: string | string[];
+    /** Prisma scalar overrides (TS type + optional import + optional Swagger metadata). */
+    extraScalars: Record<string, ScalarOverride>;
+    /**
+     * Names of user-defined annotations that custom sub-generators want to react to.
+     * The base parser still emits any `@Name` it finds in `///` comments, so registering
+     * an annotation here is documentation-and-discovery (e.g. for plugins to iterate over).
+     */
+    extraAnnotations: string[];
+};
+/**
+ * Type passed to `BaseGenerator` and to the `generate()` entry point. We keep
+ * it identical to Prisma's `GeneratorOptions` so consumers can pass DMMF results
+ * directly without casts.
+ */
+type GeneratorOptions = GeneratorOptions$1;
+interface ImportType {
+    from: string;
+    alias?: string;
+    destruct?: string[];
+}
+/** Raw map representation of `options.generator.config` as produced by Prisma. */
+type RawGeneratorConfig = Record<string, string | string[] | undefined>;
+/**
+ * Type-safe descriptor for an external module import. Equivalent to writing the import
+ * statement as a string but enforced by TypeScript: misspelled names and missing paths
+ * become compile-time errors when used together with the {@link fromModule} helper.
+ */
+type ImportDescriptor = {
+    from: string;
+    names?: readonly (string | {
+        name: string;
+        as: string;
+    })[];
+    default?: string;
+    namespace?: string;
+};
+/**
+ * Accepted forms for any `extra*` field in {@link GeneratorConfigFile}. Lets users pick
+ * between the compact inline syntax (`"Name:path|Other:path2"`), the structured
+ * {@link ImportDescriptor} shape, and the type-safe `from()` / `fromNamespace()` /
+ * `fromDefault()` helpers (which return descriptors).
+ */
+type ExtraImportConfig = string | string[] | ImportDescriptor | ImportDescriptor[];
+/**
+ * Shape of the object returned by an external configuration file referenced from
+ * `schema.prisma` via the `configFile` option. Every field is optional and overrides
+ * the value declared in the schema.
+ *
+ * @example
+ * ```ts
+ * import { from, fromNamespace, type GeneratorConfigFile } from '@tommasomeli/prisma-generator-nestjs-dto';
+ *
+ * export default {
+ *   extraValidators: from(() => import('src/common/validators'), ['IsUnique', 'IsStrongPassword']),
+ *   extraImports: [
+ *     fromNamespace('src/common/constants', 'CONSTANTS'),
+ *     from('src/users/user.fixtures', 'USER_EXAMPLE')
+ *   ]
+ * } satisfies GeneratorConfigFile;
+ * ```
+ */
+type GeneratorConfigFile = {
+    outputType?: OutputType;
+    outputStructure?: OutputStructure;
+    reExport?: boolean;
+    fileNamingStrategy?: NamingStrategy;
+    classValidator?: boolean;
+    swaggerDocs?: boolean;
+    prettier?: boolean;
+    schemaDir?: string;
+    emitManifest?: boolean;
+    extraDecorators?: ExtraImportConfig;
+    extraValidators?: ExtraImportConfig;
+    extraImports?: ExtraImportConfig;
+    extraGenerators?: ExtraImportConfig;
+    /**
+     * Per-scalar overrides. The key is the Prisma scalar name (`'Decimal'`, `'Json'`, ...);
+     * the value is a {@link ScalarOverride} describing the TS type, optional import, and
+     * optional Swagger metadata. Only available from the external `configFile` since the
+     * `schema.prisma` generator block cannot express nested objects.
+     */
+    extraScalars?: Record<string, ScalarOverride>;
+    /**
+     * Custom annotation names that downstream sub-generators recognise. Plain strings
+     * (one or many) — no imports needed, since annotations live in Prisma `///` comments.
+     * Consumed by plugins via `BaseGenerator.getAnnotation(field, name)` /
+     * `BaseGenerator.hasAnnotation(field, name)`, or via the exposed `config.extraAnnotations`.
+     */
+    extraAnnotations?: string | string[];
+};
+
+declare const DTO_IGNORE_MODEL = "DtoIgnoreModel";
+declare const DTO_API_EXTRA_MODELS = "DtoApiExtraModels";
+declare const DTO_READ_ONLY = "DtoReadOnly";
+declare const DTO_CREATE_HIDDEN = "DtoCreateHidden";
+declare const DTO_UPDATE_HIDDEN = "DtoUpdateHidden";
+declare const DTO_ENTITY_HIDDEN = "DtoEntityHidden";
+declare const DTO_API_HIDDEN = "DtoApiHidden";
+declare const DTO_HIDDEN = "DtoHidden";
+declare const DTO_CREATED_AT = "createdAt";
+declare const DTO_CREATE_OPTIONAL = "DtoCreateOptional";
+declare const DTO_CREATE_REQUIRED = "DtoCreateRequired";
+declare const DTO_UPDATE_OPTIONAL = "DtoUpdateOptional";
+declare const DTO_UPDATE_REQUIRED = "DtoUpdateRequired";
+declare const DTO_OVERRIDE_TYPE = "DtoOverrideType";
+declare const DTO_OVERRIDE_API_PROPERTY_TYPE = "DtoOverrideApiPropertyType";
+declare const DTO_CREATE_VALIDATE_IF = "DtoCreateValidateIf";
+declare const DTO_UPDATE_VALIDATE_IF = "DtoUpdateValidateIf";
+/** Annotations that hide a field from the Entity DTO surface (and therefore from API responses). */
+declare const ENTITY_HIDDEN_ANNOTATIONS: string[];
+/** Accepts both parsed annotations and raw `documentation` strings (used pre-pipeline). */
+declare function isEntityHidden(field: {
+    annotations?: Annotation[];
+    documentation?: string | null;
+}): boolean;
+
+/**
+ * Base class for every sub-generator. Concrete generators describe how their files
+ * are named (prefix/suffix) and contribute a `generate()` that yields `File[]`.
+ * Subclasses normally only override `generate()` and rely on `getTemplate()` to
+ * render the class body (imports, decorators, validators, field declarations).
+ */
+declare abstract class BaseGenerator {
+    protected options: GeneratorOptions;
+    protected config: GeneratorConfig;
+    models: Model[];
+    constructor(options: GeneratorOptions);
+    abstract filePrefix: string;
+    abstract fileSuffix: string;
+    abstract classPrefix: string;
+    abstract classSuffix: string;
+    /** Produces the list of files this generator wants to emit. */
+    abstract generate(): Promise<File[]>;
+    /**
+     * Optional pre-pass invoked once before any built-in or plugin `generate()` runs.
+     * Receives the **shared** `Model[]` array (already filtered for `@DtoIgnoreModel`);
+     * mutating it (e.g. injecting synthetic fields, rewriting annotations) is supported
+     * and visible to every generator that runs afterwards. Defaults to no-op.
+     */
+    beforeAll(_models: Model[]): Promise<void>;
+    /**
+     * Optional post-pass invoked once after every generator's `generate()` completes,
+     * receiving the **complete** list of files produced in the run (built-ins + plugins).
+     * Return a non-empty `File[]` to append extra files (e.g. an aggregated barrel,
+     * audit report, schema export); return `void` to leave the run untouched. Defaults to no-op.
+     */
+    afterAll(_files: File[]): Promise<File[] | void>;
+    /**
+     * Reads `@ignore` fields from `.prisma` files inside `schemaDir`. Prisma
+     * strips ignored fields from the DMMF but we still want them visible to
+     * annotations like `@DtoApiHidden`, so we re-parse the raw schema.
+     */
+    private getIgnoredFields;
+    /** Parses `/// @Foo(arg, {object})` documentation strings into structured annotations. */
+    private extractAnnotations;
+    /**
+     * Returns the first annotation matching `name` on a field or model, or `undefined`.
+     * Use from custom sub-generators to react to user-defined annotations declared via
+     * `extraAnnotations` (or any built-in `@Dto*` name).
+     */
+    getAnnotation(target: {
+        annotations: Annotation[];
+    }, name: string): Annotation | undefined;
+    /** Convenience boolean form of {@link getAnnotation}. */
+    hasAnnotation(target: {
+        annotations: Annotation[];
+    }, name: string): boolean;
+    /**
+     * Adds (and merges) an import descriptor into an `ImportType[]` array, honouring
+     * the same dedup/merge rules used by the built-in pipeline. Repeated calls with
+     * the same `from` collapse named imports together; `alias` entries are stored
+     * separately from `destruct` entries on the same path.
+     */
+    protected addImport(imports: ImportType[], next: ImportType): void;
+    /**
+     * Renders an `ImportType[]` array as a multi-line `import ... from '...'` block.
+     * Absolute paths (e.g. produced by `getPath(relatedModel, outputPath)`) are rewritten
+     * as POSIX-style relative paths anchored at `outputPath`; TypeScript file extensions
+     * (`.ts` / `.mts` / `.cts` / `.tsx`) on the `from` path are stripped automatically
+     * since they are never desired in import statements.
+     */
+    protected formatImports(imports: ImportType[], outputPath?: string): string;
+    /**
+     * Returns the output path of a `model` formatted for use as an `import` specifier:
+     * same as {@link getPath} but with the TypeScript file extension stripped and a
+     * `./` prefix added when the result would otherwise look like a bare module specifier
+     * (`flat` outputStructure case). Use this when a custom sub-generator needs to
+     * reference a peer-generated file (e.g. for relations between models) and you would
+     * otherwise hand-strip `.ts` from `getPath`.
+     */
+    protected getImportPath(model: Model, fromOutputPath?: string): string;
+    /** Strips `.ts` / `.mts` / `.cts` / `.tsx` suffixes from an `import` specifier. */
+    private stripTsExtension;
+    /** File / class name transformer. Defaults to camelCase. */
+    protected getModelName(name: string): string;
+    /**
+     * Applies `@DtoOverrideType(<type>)` non-destructively. The original `model`
+     * is left untouched; callers receive a model with cloned fields whose `kind`
+     * and `type` reflect the override.
+     */
+    private applyOverrides;
+    /**
+     * Merges a new `ImportType` into the existing array. Distinct concerns are kept
+     * as separate entries (i.e. an `alias` import and a `destruct` import from the
+     * same path will not collide).
+     */
+    private mergeImport;
+    /** Collects every import the rendered class will need. */
+    private getImports;
+    /**
+     * Resolves an import `from` value for the file being emitted. Absolute paths
+     * (typically produced when a relative `from` was declared in the external config file)
+     * are rewritten as POSIX-style relative paths anchored at the output file's directory.
+     */
+    private rewriteImportPath;
+    /** Renders the `import ... from ...` block. */
+    private getImportsTemplate;
+    /**
+     * Renders the full class body (imports + class declaration with decorators and fields).
+     * Sub-generators usually feed it a `model` they already pre-filtered.
+     */
+    getTemplate(args: {
+        model: Model;
+        classValidator?: boolean;
+        swaggerDocs?: boolean;
+        outputPath?: string;
+    }): string;
+    /** Returns the absolute (or relative-to-`relativeFrom`) output path for `model`. */
+    getPath(model: Model, relativeFrom?: string): string;
+}
+
+/**
+ * Result of {@link loadConfigFile}: the parsed configuration object and the absolute
+ * directory of the file it came from. The directory is used downstream to resolve
+ * relative `from` paths declared inside the config file.
+ */
+type LoadedConfigFile = {
+    config: GeneratorConfigFile;
+    dir: string;
+    file: string;
+};
+/**
+ * Loads the configuration object referenced by `configFile`. Returns `null` when the
+ * option is unset or the file fails to load; all error paths are logged and non-fatal
+ * so misconfigurations never crash `prisma generate`.
+ */
+declare function loadConfigFile(options: GeneratorOptions): Promise<LoadedConfigFile | null>;
+/**
+ * Serializes an {@link ImportDescriptor} into the inline `Name:path` syntax that
+ * {@link Utility.parseImports} consumes downstream. Default + named combinations become
+ * two `|`-joined groups (`default as Foo:path|Bar,Baz:path`); rename aliases collapse to
+ * the local name since the generator only uses local names for annotation matching and
+ * destruct emission. When `configFileDir` is provided, relative paths are resolved
+ * against it so the resulting absolute path can later be rewritten per output file.
+ */
+declare function descriptorToImportStatement(descriptor: ImportDescriptor, configFileDir?: string): string;
+/**
+ * Merges a {@link GeneratorConfigFile} on top of the raw schema config. Values from the
+ * config file override schema values for the keys it declares; everything else passes
+ * through untouched. {@link ImportDescriptor} values are serialized into the inline
+ * `Name:path` syntax; arrays and booleans are coerced into the string-shaped values
+ * that the downstream pipeline expects.
+ *
+ * When `configFileDir` is provided, relative paths in descriptors and inline strings
+ * are anchored to that directory and emitted as absolute paths. The generator later
+ * rewrites them as relative to each output file at emit time.
+ */
+declare function applyConfigFile(rawConfig: RawGeneratorConfig, configFile: GeneratorConfigFile | null, configFileDir?: string): RawGeneratorConfig;
+/**
+ * Builds an {@link ImportDescriptor} for named exports of a module. The `symbols` argument
+ * is expected to use ES shorthand property syntax (`{ IsBool, IsUnique }`); only the keys
+ * are read, but the IDE will still flag misspellings and propagate refactor renames.
+ *
+ * @example
+ * ```ts
+ * import { IsBool, IsUnique } from 'src/common/validators';
+ * import { fromModule } from '@tommasomeli/prisma-generator-nestjs-dto';
+ *
+ * fromModule('src/common/validators', { IsBool, IsUnique });
+ * // → { from: 'src/common/validators', names: ['IsBool', 'IsUnique'] }
+ * ```
+ */
+declare function fromModule(from: string, symbols: Record<string, unknown>): ImportDescriptor;
+/** Module shape inferred from a `() => import('...')` closure type. */
+type ModuleOf<F> = F extends () => Promise<infer M> ? M : never;
+/**
+ * Descriptor builder for named imports. Accepts two forms:
+ *
+ * 1. **Type-safe** — pass a `() => import('path')` callback. TypeScript infers the module
+ *    type from the dynamic import, validates `names` against its keys, and the callback
+ *    is never invoked at runtime (no side effects). The module path is recovered from
+ *    the closure source.
+ * 2. **Concise** — pass the module specifier as a plain string. `names` are not validated
+ *    by TypeScript, but the result is identical at runtime.
+ *
+ * @example
+ * ```ts
+ * from(() => import('src/common/validators'), ['IsBool', 'IsUnique']); // type-safe
+ * from(() => import('src/common/validators'), 'IsBool');               // type-safe single
+ * from('class-validator', ['IsEmail', 'IsString']);                    // string form
+ * ```
+ */
+declare function from(modulePath: string, names: string | readonly string[]): ImportDescriptor;
+declare function from<F extends () => Promise<unknown>>(importer: F, names: (keyof ModuleOf<F> & string) | readonly (keyof ModuleOf<F> & string)[]): ImportDescriptor;
+/**
+ * Descriptor builder for `import * as alias from 'path'`. Accepts the same dual form as
+ * {@link from}: a `() => import('path')` callback (path validated by TS) or a plain string.
+ *
+ * @example
+ * ```ts
+ * fromNamespace(() => import('src/common/constants'), 'CONSTANTS');
+ * fromNamespace('lodash', 'Lodash');
+ * ```
+ */
+declare function fromNamespace(modulePath: string, alias: string): ImportDescriptor;
+declare function fromNamespace<F extends () => Promise<unknown>>(importer: F, alias: string): ImportDescriptor;
+/**
+ * Descriptor builder for `import Default[, { named }] from 'path'`. Accepts the dual
+ * form (closure or string) and an optional `names` payload validated against the module
+ * type when the closure form is used.
+ *
+ * @example
+ * ```ts
+ * fromDefault(() => import('lodash'), 'Lodash');
+ * fromDefault(() => import('src/lib'), 'Lib', ['helperA', 'helperB']);
+ * fromDefault('lodash', 'Lodash');
+ * ```
+ */
+declare function fromDefault(modulePath: string, defaultName: string, names?: string | readonly string[]): ImportDescriptor;
+declare function fromDefault<F extends () => Promise<{
+    default: unknown;
+}>>(importer: F, defaultName: string, names?: (keyof ModuleOf<F> & string) | readonly (keyof ModuleOf<F> & string)[]): ImportDescriptor;
+/** Convenience for `import * as Alias from 'path'`. */
+declare function namespaceFrom(from: string, namespaceAlias: string): ImportDescriptor;
+/** Convenience for `import Default from 'path'`, optionally with named imports. */
+declare function defaultFrom(from: string, defaultName: string, namedSymbols?: Record<string, unknown>): ImportDescriptor;
+
+declare const ANNOTATION_NAME_REGEX: RegExp;
+declare const ANNOTATION_PARAMS_REGEX: RegExp;
+declare const ANNOTATION_PARAMS_SPLIT_REGEX: RegExp;
+declare const PRISMA_SCALAR: Record<string, string>;
+declare const PRISMA_SCALAR_TYPE: Record<string, string>;
+declare const PRISMA_SCALAR_FORMAT: Record<string, {
+    type: string;
+    format?: string;
+}>;
+declare const SWAGGER_DECORATORS: string[];
+declare const SWAGGER_API_PROPERTY_DECORATORS: string[];
+declare const CLASS_TRANSFORMER_DECORATORS: string[];
+declare const CLASS_VALIDATOR_DECORATORS: string[];
+
+/**
+ * Entry point used by `@prisma/generator-helper`. Executes every registered
+ * generator (built-in + user-provided), writes the resulting files to disk
+ * and, when enabled, emits `index.ts` barrels for re-exports.
+ */
+declare function generate(options: GeneratorOptions): Promise<void>;
+
+declare class EntityDtoGenerator extends BaseGenerator {
+    filePrefix: string;
+    fileSuffix: string;
+    classPrefix: string;
+    classSuffix: string;
+    generate(): Promise<File[]>;
+}
+
+declare class CreateDtoGenerator extends BaseGenerator {
+    filePrefix: string;
+    fileSuffix: string;
+    classPrefix: string;
+    classSuffix: string;
+    generate(): Promise<File[]>;
+}
+
+declare class UpdateDtoGenerator extends BaseGenerator {
+    filePrefix: string;
+    fileSuffix: string;
+    classPrefix: string;
+    classSuffix: string;
+    generate(): Promise<File[]>;
+}
+
+/**
+ * Emits runtime-side artifacts that the Prisma DMMF does not surface directly:
+ *
+ * - `manifest.ts`: per-model `primaryKey`, `entityFields` (mirrors `isEntityHidden`)
+ *   and `relations.{type,isList}`. Useful for select builders, audit logs, etc.
+ * - `model-entity-map.ts`: a type-only map `Prisma.ModelName -> generated Entity class`,
+ *   handy for typing dynamic `select` paths.
+ *
+ * Opt-in via the `emitManifest` config option (defaults to `false`).
+ */
+declare class ManifestGenerator extends BaseGenerator {
+    filePrefix: string;
+    fileSuffix: string;
+    classPrefix: string;
+    classSuffix: string;
+    generate(): Promise<File[]>;
+}
+
+/**
+ * Stateless helpers used by the generator pipeline: leveled logger with a
+ * configurable prefix, boolean parsing, and the import-statement parser used by
+ * every `extra*` config option.
+ */
+declare class Utility {
+    private static prefix;
+    /** Override the global log prefix (defaults to the package name). */
+    static setLogPrefix(prefix: string): void;
+    static log(message: any, ...data: any[]): void;
+    static warn(message: any, ...data: any[]): void;
+    static error(message: any, ...data: any[]): void;
+    /**
+     * Parses a string into a boolean. Accepts native booleans and the Prisma-style
+     * stringified values that come from `schema.prisma` config options.
+     */
+    static parseBoolean(value: string | boolean | undefined): boolean;
+    /**
+     * Parses one or more import declarations from the value of an `extra*` config option.
+     * The only supported syntax is the compact inline form:
+     *
+     * ```prisma
+     * extraValidators = "IsUnique,IsBool:src/common/validators|IsAdult:src/common/validators/is-adult"
+     * ```
+     *
+     * - `Foo,Bar:path` — named imports.
+     * - `* as Foo:path` — namespace import.
+     * - `default as Foo:path` — default import.
+     * - `|` — separator for multiple groups (different paths).
+     *
+     * For anything more elaborate (rename, default + named, type-safe paths, ...) use a
+     * `configFile` with `ImportDescriptor` or the `from()` / `fromNamespace()` / `fromDefault()`
+     * helpers.
+     *
+     * Also accepts an array of strings, with each entry already containing one or more
+     * `|`-separated groups.
+     */
+    static parseImports(value: string | string[] | undefined): ImportType[];
+    /**
+     * Parses `extraAnnotations` into a deduplicated list of annotation names.
+     * Accepts a single comma/whitespace-separated string, a string array, or a mix:
+     * `"@DtoFoo, DtoBar"`, `["DtoFoo", "DtoBar"]`, `"DtoFoo DtoBar"`. Leading `@`
+     * characters are stripped so plugin authors can refer to them either way.
+     */
+    static parseAnnotationNames(value: string | string[] | undefined): string[];
+    /**
+     * Parses the `extraScalars` config value. Accepts a JSON string (the form emitted by
+     * {@link applyConfigFile}) or an already-parsed `Record<string, ScalarOverride>` object.
+     * Invalid entries are skipped with a warning rather than throwing.
+     */
+    static parseExtraScalars(value: unknown): Record<string, {
+        ts: string;
+        from?: string;
+        apiType?: string;
+        format?: string;
+    }>;
+    /**
+     * @deprecated Use {@link parseImports} instead. Kept for sub-generators that
+     * relied on the public name in earlier releases.
+     */
+    static stringToImports(value: string | string[] | undefined): ImportType[];
+    /** Parses the inline `Name1,Name2:path|Other:path2` syntax. */
+    private static parseInlineImport;
+    /** Merges a new entry into an existing array, deduplicating named imports on the same path. */
+    private static mergeInto;
+}
+
+export { ANNOTATION_NAME_REGEX, ANNOTATION_PARAMS_REGEX, ANNOTATION_PARAMS_SPLIT_REGEX, type Annotation, BaseGenerator, CLASS_TRANSFORMER_DECORATORS, CLASS_VALIDATOR_DECORATORS, CreateDtoGenerator, DTO_API_EXTRA_MODELS, DTO_API_HIDDEN, DTO_CREATED_AT, DTO_CREATE_HIDDEN, DTO_CREATE_OPTIONAL, DTO_CREATE_REQUIRED, DTO_CREATE_VALIDATE_IF, DTO_ENTITY_HIDDEN, DTO_HIDDEN, DTO_IGNORE_MODEL, DTO_OVERRIDE_API_PROPERTY_TYPE, DTO_OVERRIDE_TYPE, DTO_READ_ONLY, DTO_UPDATE_HIDDEN, DTO_UPDATE_OPTIONAL, DTO_UPDATE_REQUIRED, DTO_UPDATE_VALIDATE_IF, ENTITY_HIDDEN_ANNOTATIONS, EntityDtoGenerator as EntityGenerator, type ExtraImportConfig, type Field, type File, type GeneratorConfig, type GeneratorConfigFile, type GeneratorOptions, type ImportDescriptor, type ImportType, type LoadedConfigFile, ManifestGenerator, type Model, type ModuleOf, type NamingStrategy, type OutputStructure, type OutputType, PRISMA_SCALAR, PRISMA_SCALAR_FORMAT, PRISMA_SCALAR_TYPE, type RawGeneratorConfig, SWAGGER_API_PROPERTY_DECORATORS, SWAGGER_DECORATORS, type ScalarOverride, UpdateDtoGenerator, Utility, applyConfigFile, defaultFrom, descriptorToImportStatement, from, fromDefault, fromModule, fromNamespace, generate, isEntityHidden, loadConfigFile, namespaceFrom };