@nx/nest 19.8.0 → 20.0.0-beta.0

package/generators.json

@@ -25,77 +25,77 @@
       "description": "Create a new NestJS library."
     },
     "class": {
-      "factory": "./src/generators/class/class#classGeneratorInternal",
+      "factory": "./src/generators/class/class",
       "schema": "./src/generators/class/schema.json",
       "description": "Run the `class` NestJS generator with Nx project support."
     },
     "controller": {
-      "factory": "./src/generators/controller/controller#controllerGeneratorInternal",
+      "factory": "./src/generators/controller/controller",
       "schema": "./src/generators/controller/schema.json",
       "description": "Run the `controller` NestJS generator with Nx project support."
     },
     "decorator": {
-      "factory": "./src/generators/decorator/decorator#decoratorGeneratorInternal",
+      "factory": "./src/generators/decorator/decorator",
       "schema": "./src/generators/decorator/schema.json",
       "description": "Run the `decorator` NestJS generator with Nx project support."
     },
     "filter": {
-      "factory": "./src/generators/filter/filter#filterGeneratorInternal",
+      "factory": "./src/generators/filter/filter",
       "schema": "./src/generators/filter/schema.json",
       "description": "Run the `filter` NestJS generator with Nx project support."
     },
     "gateway": {
-      "factory": "./src/generators/gateway/gateway#gatewayGeneratorInternal",
+      "factory": "./src/generators/gateway/gateway",
       "schema": "./src/generators/gateway/schema.json",
       "description": "Run the `gateway` NestJS generator with Nx project support."
     },
     "guard": {
-      "factory": "./src/generators/guard/guard#guardGeneratorInternal",
+      "factory": "./src/generators/guard/guard",
       "schema": "./src/generators/guard/schema.json",
       "description": "Run the `guard` NestJS generator with Nx project support."
     },
     "interceptor": {
-      "factory": "./src/generators/interceptor/interceptor#interceptorGeneratorInternal",
+      "factory": "./src/generators/interceptor/interceptor",
       "schema": "./src/generators/interceptor/schema.json",
       "description": "Run the `interceptor` NestJS generator with Nx project support."
     },
     "interface": {
-      "factory": "./src/generators/interface/interface#interfaceGeneratorInternal",
+      "factory": "./src/generators/interface/interface",
       "schema": "./src/generators/interface/schema.json",
       "description": "Run the `interface` NestJS generator with Nx project support."
     },
     "middleware": {
-      "factory": "./src/generators/middleware/middleware#middlewareGeneratorInternal",
+      "factory": "./src/generators/middleware/middleware",
       "schema": "./src/generators/middleware/schema.json",
       "description": "Run the `middleware` NestJS generator with Nx project support."
     },
     "module": {
-      "factory": "./src/generators/module/module#moduleGeneratorInternal",
+      "factory": "./src/generators/module/module",
       "schema": "./src/generators/module/schema.json",
       "description": "Run the `module` NestJS generator with Nx project support."
     },
     "pipe": {
-      "factory": "./src/generators/pipe/pipe#pipeGeneratorInternal",
+      "factory": "./src/generators/pipe/pipe",
       "schema": "./src/generators/pipe/schema.json",
       "description": "Run the `pipe` NestJS generator with Nx project support."
     },
     "provider": {
-      "factory": "./src/generators/provider/provider#providerGeneratorInternal",
+      "factory": "./src/generators/provider/provider",
       "schema": "./src/generators/provider/schema.json",
       "description": "Run the `provider` NestJS generator with Nx project support."
     },
     "resolver": {
-      "factory": "./src/generators/resolver/resolver#resolverGeneratorInternal",
+      "factory": "./src/generators/resolver/resolver",
       "schema": "./src/generators/resolver/schema.json",
       "description": "Run the `resolver` NestJS generator with Nx project support."
     },
     "resource": {
-      "factory": "./src/generators/resource/resource#resourceGeneratorInternal",
+      "factory": "./src/generators/resource/resource",
       "schema": "./src/generators/resource/schema.json",
       "description": "Run the `resource` NestJS generator with Nx project support."
     },
     "service": {
-      "factory": "./src/generators/service/service#serviceGeneratorInternal",
+      "factory": "./src/generators/service/service",
       "schema": "./src/generators/service/schema.json",
       "description": "Run the `service` NestJS generator with Nx project support."
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/nest",
-  "version": "19.8.0",
+  "version": "20.0.0-beta.0",
   "private": false,
   "description": "The Nx Plugin for Nest contains executors and generators for allowing your workspace to create powerful Nest best in class APIs.",
   "repository": {
@@ -32,13 +32,13 @@
   },
   "dependencies": {
     "@nestjs/schematics": "^9.1.0",
-    "@nx/devkit": "19.8.0",
-    "@nx/js": "19.8.0",
-    "@nx/eslint": "19.8.0",
-    "@nx/node": "19.8.0",
+    "@nx/devkit": "20.0.0-beta.0",
+    "@nx/js": "20.0.0-beta.0",
+    "@nx/eslint": "20.0.0-beta.0",
+    "@nx/node": "20.0.0-beta.0",
     "@phenomnomnominal/tsquery": "~5.0.1",
     "tslib": "^2.3.0",
-    "@nrwl/nest": "19.8.0"
+    "@nrwl/nest": "20.0.0-beta.0"
   },
   "publishConfig": {
     "access": "public"

package/src/generators/application/application.js

@@ -10,7 +10,6 @@ const ensure_dependencies_1 = require("../../utils/ensure-dependencies");
 async function applicationGenerator(tree, rawOptions) {
     return await applicationGeneratorInternal(tree, {
         addPlugin: false,
-        projectNameAndRootFormat: 'derived',
         ...rawOptions,
     });
 }

package/src/generators/application/lib/normalize-options.js

@@ -12,7 +12,6 @@ async function normalizeOptions(tree, options) {
         directory: options.directory,
         projectNameAndRootFormat: options.projectNameAndRootFormat,
         rootProject: options.rootProject,
-        callingGenerator: '@nx/nest:application',
     });
     options.rootProject = appProjectRoot === '.';
     options.projectNameAndRootFormat = projectNameAndRootFormat;

package/src/generators/class/class.d.ts

@@ -1,6 +1,5 @@
 import type { Tree } from '@nx/devkit';
 import type { NestGeneratorWithLanguageOption, NestGeneratorWithTestOption } from '../utils';
 export type ClassGeneratorOptions = NestGeneratorWithLanguageOption & NestGeneratorWithTestOption;
-export declare function classGenerator(tree: Tree, rawOptions: ClassGeneratorOptions): Promise<void>;
-export declare function classGeneratorInternal(tree: Tree, rawOptions: ClassGeneratorOptions): Promise<any>;
+export declare function classGenerator(tree: Tree, rawOptions: ClassGeneratorOptions): Promise<any>;
 export default classGenerator;

package/src/generators/class/class.js

@@ -1,21 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.classGenerator = classGenerator;
-exports.classGeneratorInternal = classGeneratorInternal;
 const utils_1 = require("../utils");
 async function classGenerator(tree, rawOptions) {
-    await classGeneratorInternal(tree, {
-        nameAndDirectoryFormat: 'derived',
-        ...rawOptions,
-    });
-}
-async function classGeneratorInternal(tree, rawOptions) {
     const options = await normalizeClassOptions(tree, rawOptions);
     return (0, utils_1.runNestSchematic)(tree, 'class', options);
 }
 exports.default = classGenerator;
 async function normalizeClassOptions(tree, options) {
-    const normalizedOptions = await (0, utils_1.normalizeOptions)(tree, 'class', '@nx/nest:class', options);
+    const normalizedOptions = await (0, utils_1.normalizeOptions)(tree, options);
     return {
         ...normalizedOptions,
         language: options.language,

package/src/generators/controller/controller.d.ts

@@ -4,6 +4,5 @@ export type ControllerGeneratorOptions = NestGeneratorWithLanguageOption & NestG
     module?: string;
     skipImport?: boolean;
 };
-export declare function controllerGenerator(tree: Tree, rawOptions: ControllerGeneratorOptions): Promise<void>;
-export declare function controllerGeneratorInternal(tree: Tree, rawOptions: ControllerGeneratorOptions): Promise<any>;
+export declare function controllerGenerator(tree: Tree, rawOptions: ControllerGeneratorOptions): Promise<any>;
 export default controllerGenerator;

package/src/generators/controller/controller.js

@@ -1,21 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.controllerGenerator = controllerGenerator;
-exports.controllerGeneratorInternal = controllerGeneratorInternal;
 const utils_1 = require("../utils");
 async function controllerGenerator(tree, rawOptions) {
-    await controllerGeneratorInternal(tree, {
-        nameAndDirectoryFormat: 'derived',
-        ...rawOptions,
-    });
-}
-async function controllerGeneratorInternal(tree, rawOptions) {
     const options = await normalizeControllerOptions(tree, rawOptions);
     return (0, utils_1.runNestSchematic)(tree, 'controller', options);
 }
 exports.default = controllerGenerator;
 async function normalizeControllerOptions(tree, options) {
-    const normalizedOptions = await (0, utils_1.normalizeOptions)(tree, 'controller', '@nx/nest:controller', options);
+    const normalizedOptions = await (0, utils_1.normalizeOptions)(tree, options);
     return {
         ...normalizedOptions,
         language: options.language,

package/src/generators/controller/schema.json

@@ -15,15 +15,6 @@
       },
       "x-prompt": "What name would you like to use?"
     },
-    "project": {
-      "description": "The Nest project to target.",
-      "type": "string",
-      "$default": {
-        "$source": "projectName"
-      },
-      "alias": "p",
-      "x-deprecated": "Provide The `directory` option instead and use the `as-provided` format. the project will be determined from the directory provided. It will be removed in Nx v20."
-    },
     "nameAndDirectoryFormat": {
       "description": "Whether to generate the component in the directory as provided, relative to the current working directory and ignoring the project (`as-provided`) or generate it using the project and directory relative to the workspace root (`derived`).",
       "type": "string",
@@ -46,12 +37,6 @@
       "enum": ["jest", "none"],
       "default": "jest"
     },
-    "flat": {
-      "description": "Flag to indicate if a directory is created.",
-      "x-deprecated": "Provide the `directory` option instead and use the `as-provided` format. It will be removed in Nx v20.",
-      "type": "boolean",
-      "default": false
-    },
     "language": {
       "description": "Nest controller language.",
       "type": "string",

package/src/generators/decorator/decorator.d.ts

@@ -1,6 +1,5 @@
 import type { Tree } from '@nx/devkit';
 import type { NestGeneratorWithLanguageOption } from '../utils';
 export type DecoratorGeneratorOptions = NestGeneratorWithLanguageOption;
-export declare function decoratorGenerator(tree: Tree, rawOptions: DecoratorGeneratorOptions): Promise<void>;
-export declare function decoratorGeneratorInternal(tree: Tree, rawOptions: DecoratorGeneratorOptions): Promise<any>;
+export declare function decoratorGenerator(tree: Tree, rawOptions: DecoratorGeneratorOptions): Promise<any>;
 export default decoratorGenerator;

package/src/generators/decorator/decorator.js

@@ -1,21 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.decoratorGenerator = decoratorGenerator;
-exports.decoratorGeneratorInternal = decoratorGeneratorInternal;
 const utils_1 = require("../utils");
 async function decoratorGenerator(tree, rawOptions) {
-    await decoratorGeneratorInternal(tree, {
-        nameAndDirectoryFormat: 'derived',
-        ...rawOptions,
-    });
-}
-async function decoratorGeneratorInternal(tree, rawOptions) {
     const options = await normalizeDecoratorOptions(tree, rawOptions);
     return (0, utils_1.runNestSchematic)(tree, 'decorator', options);
 }
 exports.default = decoratorGenerator;
 async function normalizeDecoratorOptions(tree, options) {
-    const normalizedOptions = await (0, utils_1.normalizeOptions)(tree, 'decorator', '@nx/nest:decorator', options);
+    const normalizedOptions = await (0, utils_1.normalizeOptions)(tree, options);
     return {
         ...normalizedOptions,
         language: options.language,

package/src/generators/decorator/schema.json

@@ -20,15 +20,6 @@
       "type": "string",
       "enum": ["as-provided", "derived"]
     },
-    "project": {
-      "description": "The Nest project to target.",
-      "type": "string",
-      "$default": {
-        "$source": "projectName"
-      },
-      "alias": "p",
-      "x-deprecated": "Provide The `directory` option instead and use the `as-provided` format. the project will be determined from the directory provided. It will be removed in Nx v20."
-    },
     "directory": {
       "description": "Directory where the generated files are placed. when `--nameAndDirectoryFormat=as-provided`, it will be relative to the current working directory. otherwise, it will be relative to the workspace root.",
       "type": "string",
@@ -40,12 +31,6 @@
       "default": false,
       "x-priority": "internal"
     },
-    "flat": {
-      "description": "Flag to indicate if a directory is created.",
-      "x-deprecated": "Provide the `directory` option instead and use the `as-provided` format. It will be removed in Nx v20.",
-      "type": "boolean",
-      "default": true
-    },
     "language": {
       "description": "Nest decorator language.",
       "type": "string",

package/src/generators/filter/filter.d.ts

@@ -1,6 +1,5 @@
 import type { Tree } from '@nx/devkit';
 import type { NestGeneratorWithLanguageOption, NestGeneratorWithTestOption } from '../utils';
 export type FilterGeneratorOptions = NestGeneratorWithLanguageOption & NestGeneratorWithTestOption;
-export declare function filterGenerator(tree: Tree, rawOptions: FilterGeneratorOptions): Promise<void>;
-export declare function filterGeneratorInternal(tree: Tree, rawOptions: FilterGeneratorOptions): Promise<any>;
+export declare function filterGenerator(tree: Tree, rawOptions: FilterGeneratorOptions): Promise<any>;
 export default filterGenerator;

package/src/generators/filter/filter.js

@@ -1,21 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.filterGenerator = filterGenerator;
-exports.filterGeneratorInternal = filterGeneratorInternal;
 const utils_1 = require("../utils");
 async function filterGenerator(tree, rawOptions) {
-    await filterGeneratorInternal(tree, {
-        nameAndDirectoryFormat: 'derived',
-        ...rawOptions,
-    });
-}
-async function filterGeneratorInternal(tree, rawOptions) {
     const options = await normalizeFilterOptions(tree, rawOptions);
     return (0, utils_1.runNestSchematic)(tree, 'filter', options);
 }
 exports.default = filterGenerator;
 async function normalizeFilterOptions(tree, options) {
-    const normalizedOptions = await (0, utils_1.normalizeOptions)(tree, 'filter', '@nx/nest:filter', options);
+    const normalizedOptions = await (0, utils_1.normalizeOptions)(tree, options);
     return {
         ...normalizedOptions,
         language: options.language,

package/src/generators/filter/schema.json

@@ -20,15 +20,6 @@
       "type": "string",
       "enum": ["as-provided", "derived"]
     },
-    "project": {
-      "description": "The Nest project to target.",
-      "type": "string",
-      "$default": {
-        "$source": "projectName"
-      },
-      "alias": "p",
-      "x-deprecated": "Provide The `directory` option instead and use the `as-provided` format. the project will be determined from the directory provided. It will be removed in Nx v20."
-    },
     "directory": {
       "description": "Directory where the generated files are placed. when `--nameAndDirectoryFormat=as-provided`, it will be relative to the current working directory. otherwise, it will be relative to the workspace root.",
       "type": "string",
@@ -46,12 +37,6 @@
       "enum": ["jest", "none"],
       "default": "jest"
     },
-    "flat": {
-      "description": "Flag to indicate if a directory is created.",
-      "x-deprecated": "Provide the `directory` option instead and use the `as-provided` format. It will be removed in Nx v20.",
-      "type": "boolean",
-      "default": true
-    },
     "language": {
       "description": "Nest filter language.",
       "type": "string",

package/src/generators/gateway/gateway.d.ts

@@ -1,6 +1,5 @@
 import type { Tree } from '@nx/devkit';
 import type { NestGeneratorWithLanguageOption, NestGeneratorWithTestOption } from '../utils';
 export type GatewayGeneratorOptions = NestGeneratorWithLanguageOption & NestGeneratorWithTestOption;
-export declare function gatewayGenerator(tree: Tree, rawOptions: GatewayGeneratorOptions): Promise<void>;
-export declare function gatewayGeneratorInternal(tree: Tree, rawOptions: GatewayGeneratorOptions): Promise<any>;
+export declare function gatewayGenerator(tree: Tree, rawOptions: GatewayGeneratorOptions): Promise<any>;
 export default gatewayGenerator;

package/src/generators/gateway/gateway.js

@@ -1,21 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.gatewayGenerator = gatewayGenerator;
-exports.gatewayGeneratorInternal = gatewayGeneratorInternal;
 const utils_1 = require("../utils");
 async function gatewayGenerator(tree, rawOptions) {
-    await gatewayGeneratorInternal(tree, {
-        nameAndDirectoryFormat: 'derived',
-        ...rawOptions,
-    });
-}
-async function gatewayGeneratorInternal(tree, rawOptions) {
     const options = await normalizeGatewayOptions(tree, rawOptions);
     return (0, utils_1.runNestSchematic)(tree, 'gateway', options);
 }
 exports.default = gatewayGenerator;
 async function normalizeGatewayOptions(tree, options) {
-    const normalizedOptions = await (0, utils_1.normalizeOptions)(tree, 'gateway', '@nx/nest:gateway', options);
+    const normalizedOptions = await (0, utils_1.normalizeOptions)(tree, options);
     return {
         ...normalizedOptions,
         language: options.language,

package/src/generators/gateway/schema.json

@@ -20,15 +20,6 @@
       "type": "string",
       "enum": ["as-provided", "derived"]
     },
-    "project": {
-      "description": "The Nest project to target.",
-      "type": "string",
-      "$default": {
-        "$source": "projectName"
-      },
-      "alias": "p",
-      "x-deprecated": "Provide The `directory` option instead and use the `as-provided` format. the project will be determined from the directory provided. It will be removed in Nx v20."
-    },
     "directory": {
       "description": "Directory where the generated files are placed. when `--nameAndDirectoryFormat=as-provided`, it will be relative to the current working directory. otherwise, it will be relative to the workspace root.",
       "type": "string",
@@ -46,12 +37,6 @@
       "enum": ["jest", "none"],
       "default": "jest"
     },
-    "flat": {
-      "description": "Flag to indicate if a directory is created.",
-      "x-deprecated": "Provide the `directory` option instead and use the `as-provided` format. It will be removed in Nx v20.",
-      "type": "boolean",
-      "default": true
-    },
     "language": {
       "description": "Nest gateway language.",
       "type": "string",

package/src/generators/guard/guard.d.ts

@@ -1,6 +1,5 @@
 import type { Tree } from '@nx/devkit';
 import type { NestGeneratorWithLanguageOption, NestGeneratorWithTestOption } from '../utils';
 export type GuardGeneratorOptions = NestGeneratorWithLanguageOption & NestGeneratorWithTestOption;
-export declare function guardGenerator(tree: Tree, rawOptions: GuardGeneratorOptions): Promise<void>;
-export declare function guardGeneratorInternal(tree: Tree, rawOptions: GuardGeneratorOptions): Promise<any>;
+export declare function guardGenerator(tree: Tree, rawOptions: GuardGeneratorOptions): Promise<any>;
 export default guardGenerator;

package/src/generators/guard/guard.js

@@ -1,21 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.guardGenerator = guardGenerator;
-exports.guardGeneratorInternal = guardGeneratorInternal;
 const utils_1 = require("../utils");
 async function guardGenerator(tree, rawOptions) {
-    await guardGeneratorInternal(tree, {
-        nameAndDirectoryFormat: 'derived',
-        ...rawOptions,
-    });
-}
-async function guardGeneratorInternal(tree, rawOptions) {
     const options = await normalizeGuardOptions(tree, rawOptions);
     return (0, utils_1.runNestSchematic)(tree, 'guard', options);
 }
 exports.default = guardGenerator;
 async function normalizeGuardOptions(tree, options) {
-    const normalizedOptions = await (0, utils_1.normalizeOptions)(tree, 'guard', '@nx/nest:guard', options);
+    const normalizedOptions = await (0, utils_1.normalizeOptions)(tree, options);
     return {
         ...normalizedOptions,
         language: options.language,

package/src/generators/guard/schema.json

@@ -20,15 +20,6 @@
       "type": "string",
       "enum": ["as-provided", "derived"]
     },
-    "project": {
-      "description": "The Nest project to target.",
-      "type": "string",
-      "$default": {
-        "$source": "projectName"
-      },
-      "alias": "p",
-      "x-deprecated": "Provide The `directory` option instead and use the `as-provided` format. the project will be determined from the directory provided. It will be removed in Nx v20."
-    },
     "directory": {
       "description": "Directory where the generated files are placed. when `--nameAndDirectoryFormat=as-provided`, it will be relative to the current working directory. otherwise, it will be relative to the workspace root.",
       "type": "string",
@@ -46,12 +37,6 @@
       "enum": ["jest", "none"],
       "default": "jest"
     },
-    "flat": {
-      "description": "Flag to indicate if a directory is created.",
-      "x-deprecated": "Provide the `directory` option instead and use the `as-provided` format. It will be removed in Nx v20.",
-      "type": "boolean",
-      "default": true
-    },
     "language": {
       "description": "Nest guard language.",
       "type": "string",

package/src/generators/interceptor/interceptor.d.ts

@@ -1,6 +1,5 @@
 import type { Tree } from '@nx/devkit';
 import type { NestGeneratorWithLanguageOption, NestGeneratorWithTestOption } from '../utils';
 export type InterceptorGeneratorOptions = NestGeneratorWithLanguageOption & NestGeneratorWithTestOption;
-export declare function interceptorGenerator(tree: Tree, rawOptions: InterceptorGeneratorOptions): Promise<void>;
-export declare function interceptorGeneratorInternal(tree: Tree, rawOptions: InterceptorGeneratorOptions): Promise<any>;
+export declare function interceptorGenerator(tree: Tree, rawOptions: InterceptorGeneratorOptions): Promise<any>;
 export default interceptorGenerator;

package/src/generators/interceptor/interceptor.js

@@ -1,21 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.interceptorGenerator = interceptorGenerator;
-exports.interceptorGeneratorInternal = interceptorGeneratorInternal;
 const utils_1 = require("../utils");
 async function interceptorGenerator(tree, rawOptions) {
-    await interceptorGeneratorInternal(tree, {
-        nameAndDirectoryFormat: 'derived',
-        ...rawOptions,
-    });
-}
-async function interceptorGeneratorInternal(tree, rawOptions) {
     const options = await normalizeInterceptorOptions(tree, rawOptions);
     return (0, utils_1.runNestSchematic)(tree, 'interceptor', options);
 }
 exports.default = interceptorGenerator;
 async function normalizeInterceptorOptions(tree, options) {
-    const normalizedOptions = await (0, utils_1.normalizeOptions)(tree, 'interceptor', '@nx/nest:interceptor', options);
+    const normalizedOptions = await (0, utils_1.normalizeOptions)(tree, options);
     return {
         ...normalizedOptions,
         language: options.language,

package/src/generators/interceptor/schema.json

@@ -20,15 +20,6 @@
       "type": "string",
       "enum": ["as-provided", "derived"]
     },
-    "project": {
-      "description": "The Nest project to target.",
-      "type": "string",
-      "$default": {
-        "$source": "projectName"
-      },
-      "alias": "p",
-      "x-deprecated": "Provide The `directory` option instead and use the `as-provided` format. the project will be determined from the directory provided. It will be removed in Nx v20."
-    },
     "directory": {
       "description": "Directory where the generated files are placed. when `--nameAndDirectoryFormat=as-provided`, it will be relative to the current working directory. otherwise, it will be relative to the workspace root.",
       "type": "string",
@@ -46,12 +37,6 @@
       "enum": ["jest", "none"],
       "default": "jest"
     },
-    "flat": {
-      "description": "Flag to indicate if a directory is created.",
-      "x-deprecated": "Provide the `directory` option instead and use the `as-provided` format. It will be removed in Nx v20.",
-      "type": "boolean",
-      "default": true
-    },
     "language": {
       "description": "Nest interceptor language.",
       "type": "string",

package/src/generators/interface/interface.d.ts

@@ -1,6 +1,5 @@
 import type { Tree } from '@nx/devkit';
 import type { NestGeneratorOptions } from '../utils';
 export type InterfaceGeneratorOptions = NestGeneratorOptions;
-export declare function interfaceGenerator(tree: Tree, rawOptions: InterfaceGeneratorOptions): Promise<void>;
-export declare function interfaceGeneratorInternal(tree: Tree, rawOptions: InterfaceGeneratorOptions): Promise<any>;
+export declare function interfaceGenerator(tree: Tree, rawOptions: InterfaceGeneratorOptions): Promise<any>;
 export default interfaceGenerator;

package/src/generators/interface/interface.js

@@ -1,16 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.interfaceGenerator = interfaceGenerator;
-exports.interfaceGeneratorInternal = interfaceGeneratorInternal;
 const utils_1 = require("../utils");
 async function interfaceGenerator(tree, rawOptions) {
-    await interfaceGeneratorInternal(tree, {
-        nameAndDirectoryFormat: 'derived',
-        ...rawOptions,
-    });
-}
-async function interfaceGeneratorInternal(tree, rawOptions) {
-    const options = await (0, utils_1.normalizeOptions)(tree, 'interface', '@nx/nest:interface', rawOptions);
+    const options = await (0, utils_1.normalizeOptions)(tree, rawOptions);
     return (0, utils_1.runNestSchematic)(tree, 'interface', options);
 }
 exports.default = interfaceGenerator;

package/src/generators/library/lib/normalize-options.js

@@ -13,7 +13,6 @@ async function normalizeOptions(tree, options) {
         directory: options.directory,
         importPath: options.importPath,
         projectNameAndRootFormat: options.projectNameAndRootFormat,
-        callingGenerator: '@nx/nest:library',
     });
     const nxJson = (0, devkit_1.readNxJson)(tree);
     const addPlugin = process.env.NX_ADD_PLUGINS !== 'false' &&

package/src/generators/library/library.js

@@ -11,7 +11,6 @@ const ensure_dependencies_1 = require("../../utils/ensure-dependencies");
 async function libraryGenerator(tree, rawOptions) {
     return await libraryGeneratorInternal(tree, {
         addPlugin: false,
-        projectNameAndRootFormat: 'derived',
         ...rawOptions,
     });
 }

package/src/generators/library/schema.json

@@ -30,7 +30,7 @@
     "projectNameAndRootFormat": {
       "description": "Whether to generate the project name and root directory as provided (`as-provided`) or generate them composing their values and taking the configured layout into account (`derived`).",
       "type": "string",
-      "enum": ["as-provided", "derived"]
+      "enum": ["as-provided"]
     },
     "linter": {
       "description": "The tool to use for running lint checks.",

package/src/generators/middleware/middleware.d.ts

@@ -1,6 +1,5 @@
 import type { Tree } from '@nx/devkit';
 import type { NestGeneratorWithLanguageOption, NestGeneratorWithTestOption } from '../utils';
 export type MiddlewareGeneratorOptions = NestGeneratorWithLanguageOption & NestGeneratorWithTestOption;
-export declare function middlewareGenerator(tree: Tree, rawOptions: MiddlewareGeneratorOptions): Promise<void>;
-export declare function middlewareGeneratorInternal(tree: Tree, rawOptions: MiddlewareGeneratorOptions): Promise<any>;
+export declare function middlewareGenerator(tree: Tree, rawOptions: MiddlewareGeneratorOptions): Promise<any>;
 export default middlewareGenerator;

package/src/generators/middleware/middleware.js

@@ -1,21 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.middlewareGenerator = middlewareGenerator;
-exports.middlewareGeneratorInternal = middlewareGeneratorInternal;
 const utils_1 = require("../utils");
 async function middlewareGenerator(tree, rawOptions) {
-    await middlewareGeneratorInternal(tree, {
-        nameAndDirectoryFormat: 'derived',
-        ...rawOptions,
-    });
-}
-async function middlewareGeneratorInternal(tree, rawOptions) {
     const options = await normalizeMiddlewareOptions(tree, rawOptions);
     return (0, utils_1.runNestSchematic)(tree, 'middleware', options);
 }
 exports.default = middlewareGenerator;
 async function normalizeMiddlewareOptions(tree, options) {
-    const normalizedOptions = await (0, utils_1.normalizeOptions)(tree, 'middleware', '@nx/nest:middleware', options);
+    const normalizedOptions = await (0, utils_1.normalizeOptions)(tree, options);
     return {
         ...normalizedOptions,
         language: options.language,

package/src/generators/middleware/schema.json

@@ -18,16 +18,7 @@
     "nameAndDirectoryFormat": {
       "description": "Whether to generate the component in the directory as provided, relative to the current working directory and ignoring the project (`as-provided`) or generate it using the project and directory relative to the workspace root (`derived`).",
       "type": "string",
-      "enum": ["as-provided", "derived"]
-    },
-    "project": {
-      "description": "The Nest project to target.",
-      "type": "string",
-      "$default": {
-        "$source": "projectName"
-      },
-      "alias": "p",
-      "x-deprecated": "Provide The `directory` option instead and use the `as-provided` format. the project will be determined from the directory provided. It will be removed in Nx v20."
+      "enum": ["as-provided"]
     },
     "directory": {
       "description": "Directory where the generated files are placed. when `--nameAndDirectoryFormat=as-provided`, it will be relative to the current working directory. otherwise, it will be relative to the workspace root.",
@@ -46,12 +37,6 @@
       "enum": ["jest", "none"],
       "default": "jest"
     },
-    "flat": {
-      "description": "Flag to indicate if a directory is created.",
-      "x-deprecated": "Provide the `directory` option instead and use the `as-provided` format. It will be removed in Nx v20.",
-      "type": "boolean",
-      "default": true
-    },
     "language": {
       "description": "Nest middleware language.",
       "type": "string",

package/src/generators/module/module.d.ts

@@ -4,6 +4,5 @@ export type ModuleGeneratorOptions = NestGeneratorWithLanguageOption & {
     module?: string;
     skipImport?: boolean;
 };
-export declare function moduleGenerator(tree: Tree, rawOptions: ModuleGeneratorOptions): Promise<void>;
-export declare function moduleGeneratorInternal(tree: Tree, rawOptions: ModuleGeneratorOptions): Promise<any>;
+export declare function moduleGenerator(tree: Tree, rawOptions: ModuleGeneratorOptions): Promise<any>;
 export default moduleGenerator;

package/src/generators/module/module.js

@@ -1,21 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.moduleGenerator = moduleGenerator;
-exports.moduleGeneratorInternal = moduleGeneratorInternal;
 const utils_1 = require("../utils");
 async function moduleGenerator(tree, rawOptions) {
-    await moduleGeneratorInternal(tree, {
-        nameAndDirectoryFormat: 'derived',
-        ...rawOptions,
-    });
-}
-async function moduleGeneratorInternal(tree, rawOptions) {
     const options = await normalizeModuleOptions(tree, rawOptions);
     return (0, utils_1.runNestSchematic)(tree, 'module', options);
 }
 exports.default = moduleGenerator;
 async function normalizeModuleOptions(tree, options) {
-    const normalizedOption = await (0, utils_1.normalizeOptions)(tree, 'module', '@nx/nest:module', options);
+    const normalizedOption = await (0, utils_1.normalizeOptions)(tree, options);
     return {
         ...normalizedOption,
         language: options.language,

package/src/generators/module/schema.json

@@ -20,15 +20,6 @@
       "type": "string",
       "enum": ["as-provided", "derived"]
     },
-    "project": {
-      "description": "The Nest project to target.",
-      "type": "string",
-      "$default": {
-        "$source": "projectName"
-      },
-      "alias": "p",
-      "x-deprecated": "Provide The `directory` option instead and use the `as-provided` format. the project will be determined from the directory provided. It will be removed in Nx v20."
-    },
     "directory": {
       "description": "Directory where the generated files are placed. when `--nameAndDirectoryFormat=as-provided`, it will be relative to the current working directory. otherwise, it will be relative to the workspace root.",
       "type": "string",
@@ -40,12 +31,6 @@
       "default": false,
       "x-priority": "internal"
     },
-    "flat": {
-      "description": "Flag to indicate if a directory is created.",
-      "x-deprecated": "Provide the `directory` option instead and use the `as-provided` format. It will be removed in Nx v20.",
-      "type": "boolean",
-      "default": false
-    },
     "language": {
       "description": "Nest module language.",
       "type": "string",

package/src/generators/pipe/pipe.d.ts

@@ -1,6 +1,5 @@
 import type { Tree } from '@nx/devkit';
 import type { NestGeneratorWithLanguageOption, NestGeneratorWithTestOption } from '../utils';
 export type PipeGeneratorOptions = NestGeneratorWithLanguageOption & NestGeneratorWithTestOption;
-export declare function pipeGenerator(tree: Tree, rawOptions: PipeGeneratorOptions): Promise<void>;
-export declare function pipeGeneratorInternal(tree: Tree, rawOptions: PipeGeneratorOptions): Promise<any>;
+export declare function pipeGenerator(tree: Tree, rawOptions: PipeGeneratorOptions): Promise<any>;
 export default pipeGenerator;

package/src/generators/pipe/pipe.js

@@ -1,21 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pipeGenerator = pipeGenerator;
-exports.pipeGeneratorInternal = pipeGeneratorInternal;
 const utils_1 = require("../utils");
 async function pipeGenerator(tree, rawOptions) {
-    await pipeGeneratorInternal(tree, {
-        nameAndDirectoryFormat: 'derived',
-        ...rawOptions,
-    });
-}
-async function pipeGeneratorInternal(tree, rawOptions) {
     const options = await normalizePipeOptions(tree, rawOptions);
     return (0, utils_1.runNestSchematic)(tree, 'pipe', options);
 }
 exports.default = pipeGenerator;
 async function normalizePipeOptions(tree, options) {
-    const normalizedOptions = await (0, utils_1.normalizeOptions)(tree, 'pipe', '@nx/nest:pipe', options);
+    const normalizedOptions = await (0, utils_1.normalizeOptions)(tree, options);
     return {
         ...normalizedOptions,
         language: options.language,

package/src/generators/pipe/schema.json

@@ -20,15 +20,6 @@
       "type": "string",
       "enum": ["as-provided", "derived"]
     },
-    "project": {
-      "description": "The Nest project to target.",
-      "type": "string",
-      "$default": {
-        "$source": "projectName"
-      },
-      "alias": "p",
-      "x-deprecated": "Provide The `directory` option instead and use the `as-provided` format. the project will be determined from the directory provided. It will be removed in Nx v20."
-    },
     "directory": {
       "description": "Directory where the generated files are placed. when `--nameAndDirectoryFormat=as-provided`, it will be relative to the current working directory. otherwise, it will be relative to the workspace root.",
       "type": "string",
@@ -46,12 +37,6 @@
       "enum": ["jest", "none"],
       "default": "jest"
     },
-    "flat": {
-      "description": "Flag to indicate if a directory is created.",
-      "x-deprecated": "Provide the `directory` option instead and use the `as-provided` format. It will be removed in Nx v20.",
-      "type": "boolean",
-      "default": true
-    },
     "language": {
       "description": "Nest pipe language.",
       "type": "string",

package/src/generators/provider/provider.d.ts

@@ -1,6 +1,5 @@
 import type { Tree } from '@nx/devkit';
 import type { NestGeneratorWithLanguageOption, NestGeneratorWithTestOption } from '../utils';
 export type ProviderGeneratorOptions = NestGeneratorWithLanguageOption & NestGeneratorWithTestOption;
-export declare function providerGenerator(tree: Tree, rawOptions: ProviderGeneratorOptions): Promise<void>;
-export declare function providerGeneratorInternal(tree: Tree, rawOptions: ProviderGeneratorOptions): Promise<any>;
+export declare function providerGenerator(tree: Tree, rawOptions: ProviderGeneratorOptions): Promise<any>;
 export default providerGenerator;

package/src/generators/provider/provider.js

@@ -1,21 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.providerGenerator = providerGenerator;
-exports.providerGeneratorInternal = providerGeneratorInternal;
 const utils_1 = require("../utils");
 async function providerGenerator(tree, rawOptions) {
-    await providerGeneratorInternal(tree, {
-        nameAndDirectoryFormat: 'derived',
-        ...rawOptions,
-    });
-}
-async function providerGeneratorInternal(tree, rawOptions) {
     const options = await normalizeProviderOptions(tree, rawOptions);
     return (0, utils_1.runNestSchematic)(tree, 'provider', options);
 }
 exports.default = providerGenerator;
 async function normalizeProviderOptions(tree, options) {
-    const normalizedOptions = await (0, utils_1.normalizeOptions)(tree, 'provider', '@nx/nest:provider', options);
+    const normalizedOptions = await (0, utils_1.normalizeOptions)(tree, options);
     return {
         ...normalizedOptions,
         language: options.language,

package/src/generators/provider/schema.json

@@ -20,15 +20,6 @@
       "type": "string",
       "enum": ["as-provided", "derived"]
     },
-    "project": {
-      "description": "The Nest project to target.",
-      "type": "string",
-      "$default": {
-        "$source": "projectName"
-      },
-      "alias": "p",
-      "x-deprecated": "Provide The `directory` option instead and use the `as-provided` format. the project will be determined from the directory provided. It will be removed in Nx v20."
-    },
     "directory": {
       "description": "Directory where the generated files are placed. when `--nameAndDirectoryFormat=as-provided`, it will be relative to the current working directory. otherwise, it will be relative to the workspace root.",
       "type": "string",
@@ -46,12 +37,6 @@
       "enum": ["jest", "none"],
       "default": "jest"
     },
-    "flat": {
-      "description": "Flag to indicate if a directory is created.",
-      "x-deprecated": "Provide the `directory` option instead and use the `as-provided` format. It will be removed in Nx v20.",
-      "type": "boolean",
-      "default": true
-    },
     "language": {
       "description": "Nest provider language.",
       "type": "string",

package/src/generators/resolver/resolver.d.ts

@@ -1,6 +1,5 @@
 import type { Tree } from '@nx/devkit';
 import type { NestGeneratorWithLanguageOption, NestGeneratorWithTestOption } from '../utils';
 export type ResolverGeneratorOptions = NestGeneratorWithLanguageOption & NestGeneratorWithTestOption;
-export declare function resolverGenerator(tree: Tree, rawOptions: ResolverGeneratorOptions): Promise<void>;
-export declare function resolverGeneratorInternal(tree: Tree, rawOptions: ResolverGeneratorOptions): Promise<any>;
+export declare function resolverGenerator(tree: Tree, rawOptions: ResolverGeneratorOptions): Promise<any>;
 export default resolverGenerator;

package/src/generators/resolver/resolver.js

@@ -1,21 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolverGenerator = resolverGenerator;
-exports.resolverGeneratorInternal = resolverGeneratorInternal;
 const utils_1 = require("../utils");
 async function resolverGenerator(tree, rawOptions) {
-    await resolverGeneratorInternal(tree, {
-        nameAndDirectoryFormat: 'derived',
-        ...rawOptions,
-    });
-}
-async function resolverGeneratorInternal(tree, rawOptions) {
     const options = await normalizeResolverOptions(tree, rawOptions);
     return (0, utils_1.runNestSchematic)(tree, 'resolver', options);
 }
 exports.default = resolverGenerator;
 async function normalizeResolverOptions(tree, options) {
-    const normalizedOptions = await (0, utils_1.normalizeOptions)(tree, 'resolver', '@nx/nest:resolver', options);
+    const normalizedOptions = await (0, utils_1.normalizeOptions)(tree, options);
     return {
         ...normalizedOptions,
         language: options.language,

package/src/generators/resolver/schema.json

@@ -15,15 +15,6 @@
       },
       "x-prompt": "What name would you like to use?"
     },
-    "project": {
-      "description": "The Nest project to target.",
-      "type": "string",
-      "$default": {
-        "$source": "projectName"
-      },
-      "alias": "p",
-      "x-deprecated": "Provide The `directory` option instead and use the `as-provided` format. the project will be determined from the directory provided. It will be removed in Nx v20."
-    },
     "nameAndDirectoryFormat": {
       "description": "Whether to generate the project name and root directory as provided (`as-provided`) or generate them composing their values and taking the configured layout into account (`derived`).",
       "type": "string",
@@ -46,12 +37,6 @@
       "enum": ["jest", "none"],
       "default": "jest"
     },
-    "flat": {
-      "description": "Flag to indicate if a directory is created.",
-      "x-deprecated": "Provide the `directory` option instead and use the `as-provided` format. It will be removed in Nx v20.",
-      "type": "boolean",
-      "default": false
-    },
     "language": {
       "description": "Nest resolver language.",
       "type": "string",

package/src/generators/resource/resource.d.ts

@@ -1,6 +1,5 @@
 import type { Tree } from '@nx/devkit';
 import type { NestGeneratorWithLanguageOption, NestGeneratorWithResourceOption, NestGeneratorWithTestOption } from '../utils';
 export type ResourceGeneratorOptions = NestGeneratorWithLanguageOption & NestGeneratorWithTestOption & NestGeneratorWithResourceOption;
-export declare function resourceGenerator(tree: Tree, rawOptions: ResourceGeneratorOptions): Promise<void>;
-export declare function resourceGeneratorInternal(tree: Tree, rawOptions: ResourceGeneratorOptions): Promise<any>;
+export declare function resourceGenerator(tree: Tree, rawOptions: ResourceGeneratorOptions): Promise<any>;
 export default resourceGenerator;

package/src/generators/resource/resource.js

@@ -1,21 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resourceGenerator = resourceGenerator;
-exports.resourceGeneratorInternal = resourceGeneratorInternal;
 const utils_1 = require("../utils");
 async function resourceGenerator(tree, rawOptions) {
-    await resourceGeneratorInternal(tree, {
-        nameAndDirectoryFormat: 'derived',
-        ...rawOptions,
-    });
-}
-async function resourceGeneratorInternal(tree, rawOptions) {
     const options = await normalizeResourceOptions(tree, rawOptions);
     return (0, utils_1.runNestSchematic)(tree, 'resource', options);
 }
 exports.default = resourceGenerator;
 async function normalizeResourceOptions(tree, options) {
-    const normalizedOptions = await (0, utils_1.normalizeOptions)(tree, 'resource', '@nx/nest:resource', options);
+    const normalizedOptions = await (0, utils_1.normalizeOptions)(tree, options);
     return {
         ...normalizedOptions,
         language: options.language,

package/src/generators/resource/schema.json

@@ -15,15 +15,6 @@
       },
       "x-prompt": "What name would you like to use for this resource (plural, e.g., `users`)?"
     },
-    "project": {
-      "description": "The Nest project to target.",
-      "type": "string",
-      "$default": {
-        "$source": "projectName"
-      },
-      "alias": "p",
-      "x-deprecated": "Provide The `directory` option instead and use the `as-provided` format. the project will be determined from the directory provided. It will be removed in Nx v20."
-    },
     "nameAndDirectoryFormat": {
       "description": "Whether to generate the project name and root directory as provided (`as-provided`) or generate them composing their values and taking the configured layout into account (`derived`).",
       "type": "string",
@@ -46,12 +37,6 @@
       "enum": ["jest", "none"],
       "default": "jest"
     },
-    "flat": {
-      "description": "Flag to indicate if a directory is created.",
-      "x-deprecated": "Provide the `directory` option instead and use the `as-provided` format. It will be removed in Nx v20.",
-      "type": "boolean",
-      "default": false
-    },
     "language": {
       "description": "Nest class language.",
       "type": "string",

package/src/generators/service/schema.json

@@ -20,15 +20,6 @@
       "type": "string",
       "enum": ["as-provided", "derived"]
     },
-    "project": {
-      "description": "The Nest project to target.",
-      "type": "string",
-      "$default": {
-        "$source": "projectName"
-      },
-      "alias": "p",
-      "x-deprecated": "Provide The `directory` option instead and use the `as-provided` format. the project will be determined from the directory provided. It will be removed in Nx v20."
-    },
     "directory": {
       "description": "Directory where the generated files are placed. when `--nameAndDirectoryFormat=as-provided`, it will be relative to the current working directory. otherwise, it will be relative to the workspace root.",
       "type": "string",
@@ -46,12 +37,6 @@
       "enum": ["jest", "none"],
       "default": "jest"
     },
-    "flat": {
-      "description": "Flag to indicate if a directory is created.",
-      "x-deprecated": "Provide the `directory` option instead and use the `as-provided` format. It will be removed in Nx v20.",
-      "type": "boolean",
-      "default": false
-    },
     "language": {
       "description": "Nest service language.",
       "type": "string",

package/src/generators/service/service.d.ts

@@ -1,6 +1,5 @@
 import type { Tree } from '@nx/devkit';
 import type { NestGeneratorWithLanguageOption, NestGeneratorWithTestOption } from '../utils';
 export type ServiceGeneratorOptions = NestGeneratorWithLanguageOption & NestGeneratorWithTestOption;
-export declare function serviceGenerator(tree: Tree, rawOptions: ServiceGeneratorOptions): Promise<void>;
-export declare function serviceGeneratorInternal(tree: Tree, rawOptions: ServiceGeneratorOptions): Promise<any>;
+export declare function serviceGenerator(tree: Tree, rawOptions: ServiceGeneratorOptions): Promise<any>;
 export default serviceGenerator;

package/src/generators/service/service.js

@@ -1,21 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.serviceGenerator = serviceGenerator;
-exports.serviceGeneratorInternal = serviceGeneratorInternal;
 const utils_1 = require("../utils");
 async function serviceGenerator(tree, rawOptions) {
-    await serviceGeneratorInternal(tree, {
-        nameAndDirectoryFormat: 'derived',
-        ...rawOptions,
-    });
-}
-async function serviceGeneratorInternal(tree, rawOptions) {
     const options = await normalizeServiceOptions(tree, rawOptions);
     return (0, utils_1.runNestSchematic)(tree, 'service', options);
 }
 exports.default = serviceGenerator;
 async function normalizeServiceOptions(tree, options) {
-    const normalizedOptions = await (0, utils_1.normalizeOptions)(tree, 'service', '@nx/nest:service', options);
+    const normalizedOptions = await (0, utils_1.normalizeOptions)(tree, options);
     return {
         ...normalizedOptions,
         language: options.language,

package/src/generators/utils/normalize-options.d.ts

@@ -1,4 +1,4 @@
 import type { Tree } from '@nx/devkit';
 import type { NestGeneratorOptions, NormalizedOptions, UnitTestRunner } from './types';
-export declare function normalizeOptions(tree: Tree, artifactType: string, callingGenerator: string, options: NestGeneratorOptions): Promise<NormalizedOptions>;
+export declare function normalizeOptions(tree: Tree, options: NestGeneratorOptions): Promise<NormalizedOptions>;
 export declare function unitTestRunnerToSpec(unitTestRunner: UnitTestRunner | undefined): boolean | undefined;

package/src/generators/utils/normalize-options.js

@@ -3,15 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeOptions = normalizeOptions;
 exports.unitTestRunnerToSpec = unitTestRunnerToSpec;
 const artifact_name_and_directory_utils_1 = require("@nx/devkit/src/generators/artifact-name-and-directory-utils");
-async function normalizeOptions(tree, artifactType, callingGenerator, options) {
+async function normalizeOptions(tree, options) {
     const { directory, fileName } = await (0, artifact_name_and_directory_utils_1.determineArtifactNameAndDirectoryOptions)(tree, {
-        callingGenerator,
-        artifactType,
         name: options.name,
         directory: options.directory,
-        project: options.project,
-        flat: options.flat,
-        derivedDirectory: options.directory,
         nameAndDirectoryFormat: options.nameAndDirectoryFormat,
     });
     return {

package/src/generators/utils/types.d.ts

@@ -8,14 +8,6 @@ export type NestGeneratorOptions = {
     directory?: string;
     skipFormat?: boolean;
     nameAndDirectoryFormat?: NameAndDirectoryFormat;
-    /**
-     * @deprecated Provide the `directory` option instead and use the `as-provided` format. It will be removed in Nx v20.
-     */
-    flat?: boolean;
-    /**
-     * @deprecated Provide the `directory` option instead and use the `as-provided` format. The project will be determined from the directory provided. It will be removed in Nx v20.
-     */
-    project?: string;
 };
 export type NestGeneratorWithLanguageOption = NestGeneratorOptions & {
     language?: Language;