@angular/cli 19.1.0-next.2 → 19.1.0

package/lib/config/workspace-schema.d.ts

@@ -101,86 +101,102 @@ export interface SchematicOptions {
     [property: string]: any;
 }
 /**
- * Generates a new basic application definition in the "projects" subfolder of the workspace.
+ * Generates a new Angular application within your workspace. This schematic sets up the
+ * foundational structure of your project, including the root component, module, and
+ * configuration files. You can customize various aspects of the application, such as
+ * routing, styling, and testing.
  */
 export interface AngularApplicationOptionsSchema {
     /**
-     * Create an application that does not utilize zone.js.
+     * Generate an application that does not use `zone.js`.
      */
     experimentalZoneless?: boolean;
     /**
-     * Include styles inline in the root component.ts file. Only CSS styles can be included
-     * inline. Default is false, meaning that an external styles file is created and referenced
-     * in the root component.ts file.
+     * Include the styles for the root component directly within the `app.component.ts` file.
+     * Only CSS styles can be included inline. By default, a separate stylesheet file (e.g.,
+     * `app.component.css`) is created.
      */
     inlineStyle?: boolean;
     /**
-     * Include template inline in the root component.ts file. Default is false, meaning that an
-     * external template file is created and referenced in the root component.ts file.
+     * Include the HTML template for the root component directly within the `app.component.ts`
+     * file. By default, a separate template file (e.g., `app.component.html`) is created.
      */
     inlineTemplate?: boolean;
     /**
-     * Create a bare-bones project without any testing frameworks. (Use for learning purposes
-     * only.)
+     * Generate a minimal project without any testing frameworks. This is intended for learning
+     * purposes and simple experimentation, not for production applications.
      */
     minimal?: boolean;
     /**
-     * The name of the new application.
+     * The name for the new application. This name will be used for the project directory and
+     * various identifiers throughout the application's code.
      */
     name: string;
     /**
-     * A prefix to apply to generated selectors.
+     * A prefix to be added to the selectors of components generated within this application.
+     * For example, if the prefix is `my-app` and you generate a component named `my-component`,
+     * the selector will be `my-app-my-component`.
      */
     prefix?: string;
     /**
-     * The root directory of the new application.
+     * The directory where the new application's files will be created, relative to the
+     * workspace root. If not specified, the application will be created in a subfolder within
+     * the `projects` directory, using the application's name.
      */
     projectRoot?: string;
     /**
-     * Creates an application with routing enabled.
+     * Generate an application with routing already configured. This sets up the necessary files
+     * and modules for managing navigation between different views in your application.
      */
     routing?: boolean;
     /**
-     * Creates a server application using the Server Routing and App Engine APIs (Developer
+     * Set up a server application using the Server Routing and App Engine APIs (Developer
      * Preview).
      */
     serverRouting?: boolean;
     /**
-     * Skip installing dependency packages.
+     * Skip the automatic installation of packages. You will need to manually install the
+     * dependencies later.
      */
     skipInstall?: boolean;
     /**
-     * Do not add dependencies to the "package.json" file.
+     * Do not add dependencies to the `package.json` file.
      */
     skipPackageJson?: boolean;
     /**
-     * Do not create "spec.ts" test files for the application.
+     * Skip the generation of a unit test files `spec.ts`.
      */
     skipTests?: boolean;
     /**
-     * Creates an application with Server-Side Rendering (SSR) and Static Site Generation
-     * (SSG/Prerendering) enabled.
+     * Configure the application for Server-Side Rendering (SSR) and Static Site Generation
+     * (SSG/Prerendering).
      */
     ssr?: boolean;
     /**
-     * Creates an application based upon the standalone API, without NgModules.
+     * Create an application that utilizes the standalone API, eliminating the need for
+     * NgModules. This can simplify the structure of your application.
      */
     standalone?: boolean;
     /**
-     * Creates an application with stricter bundle budgets settings.
+     * Enable stricter bundle budget settings for the application. This helps to keep your
+     * application's bundle size small and improve performance. For more information, see
+     * https://angular.dev/tools/cli/template-typecheck#strict-mode
      */
     strict?: boolean;
     /**
-     * The file extension or preprocessor to use for style files.
+     * The type of stylesheet files to be created for components in the application.
      */
     style?: SchematicsAngularApplicationStyle;
     /**
-     * The view encapsulation strategy to use in the new application.
+     * Sets the view encapsulation mode for the application's components. This determines how
+     * component styles are scoped and applied.
      */
     viewEncapsulation?: ViewEncapsulation;
 }
 /**
- * The file extension or preprocessor to use for style files.
+ * The type of stylesheet files to be created for components in the application.
+ *
+ * The type of stylesheet files to be created for components in the initial project.
  */
 export declare enum SchematicsAngularApplicationStyle {
     Css = "css",
@@ -189,11 +205,16 @@ export declare enum SchematicsAngularApplicationStyle {
     Scss = "scss"
 }
 /**
- * The view encapsulation strategy to use in the new application.
+ * Sets the view encapsulation mode for the application's components. This determines how
+ * component styles are scoped and applied.
  *
- * The view encapsulation strategy to use in the new component.
+ * Sets the view encapsulation mode for the component. This determines how the component's
+ * styles are scoped and applied.
  *
- * The view encapsulation strategy to use in the initial project.
+ * Sets the view encapsulation mode for components in the initial project. This determines
+ * how component styles are scoped and applied. Options include: `Emulated` (default, styles
+ * are scoped to the component), `None` (styles are global), and `ShadowDom` (styles are
+ * encapsulated using Shadow DOM).
  */
 export declare enum ViewEncapsulation {
     Emulated = "Emulated",
@@ -201,129 +222,153 @@ export declare enum ViewEncapsulation {
     ShadowDom = "ShadowDom"
 }
 /**
- * Creates a new, generic class definition in the given project.
+ * Creates a new class in your project. Classes are the fundamental building blocks for
+ * object-oriented programming in TypeScript. They provide a blueprint for creating objects
+ * with properties and methods. This schematic helps you generate a new class with the basic
+ * structure and optional test files.
  */
 export interface AngularClassOptionsSchema {
     /**
-     * The name of the new class.
+     * The name for the new class. This will be used to create the class file (e.g.,
+     * `my-class.ts`) and, if enabled, the corresponding test file `my-class.spec.ts`.
      */
     name: string;
     /**
-     * The path at which to create the class, relative to the workspace root.
+     * The path where the class file should be created, relative to the workspace root. If not
+     * specified, the class will be created in the current directory.
      */
     path?: string;
     /**
-     * The name of the project.
+     * The name of the project where the class should be added. If not specified, the CLI will
+     * determine the project from the current directory.
      */
     project: string;
     /**
-     * Do not create "spec.ts" test files for the new class.
+     * Skip the generation of a unit test file `spec.ts` for the new class.
      */
     skipTests?: boolean;
     /**
-     * Adds a developer-defined type to the filename, in the format "name.type.ts".
+     * Adds a custom type to the filename, allowing you to create more descriptive class names.
+     * For example, if you set the type to `helper`, the filename will be `my-class.helper.ts`.
      */
     type?: string;
 }
 /**
- * Creates a new, generic component definition in the given project.
+ * Creates a new Angular component. Components are the basic building blocks of Angular
+ * applications. Each component consists of a TypeScript class, an HTML template, and an
+ * optional CSS stylesheet. Use this schematic to generate a new component in your project.
  */
 export interface AngularComponentOptionsSchema {
     /**
-     * The change detection strategy to use in the new component.
+     * Configures the change detection strategy for the component.
      */
     changeDetection?: ChangeDetection;
     /**
-     * Specifies if the style will contain `:host { display: block; }`.
+     * Adds `:host { display: block; }` to the component's stylesheet, ensuring the component
+     * renders as a block-level element. This is useful for layout purposes.
      */
     displayBlock?: boolean;
     /**
-     * The declaring NgModule exports this component.
+     * Automatically export the component from the specified NgModule, making it accessible to
+     * other modules in the application.
      */
     export?: boolean;
     /**
-     * Use default export for the component instead of a named export.
+     * Use a default export for the component in its TypeScript file instead of a named export.
      */
     exportDefault?: boolean;
     /**
-     * Create the new files at the top level of the current project.
+     * Create the component files directly in the project's `src/app` directory instead of
+     * creating a new folder for them.
      */
     flat?: boolean;
     /**
-     * Include styles inline in the component.ts file. Only CSS styles can be included inline.
-     * By default, an external styles file is created and referenced in the component.ts file.
+     * Include the component's styles directly in the `component.ts` file. By default, a
+     * separate stylesheet file (e.g., `my-component.component.css`) is created.
      */
     inlineStyle?: boolean;
     /**
-     * Include template inline in the component.ts file. By default, an external template file
-     * is created and referenced in the component.ts file.
+     * Include the component's HTML template directly in the `component.ts` file. By default, a
+     * separate template file (e.g., `my-component.component.html`) is created.
      */
     inlineTemplate?: boolean;
     /**
-     * The declaring NgModule.
+     * Specify the NgModule where the component should be declared. If not provided, the CLI
+     * will attempt to find the closest NgModule in the component's path.
      */
     module?: string;
     /**
-     * The name of the component.
+     * The name for the new component. This will be used to create the component's class,
+     * template, and stylesheet files. For example, if you provide `my-component`, the files
+     * will be named `my-component.component.ts`, `my-component.component.html`, and
+     * `my-component.component.css`.
      */
     name: string;
     /**
-     * The path at which to create the component file, relative to the current workspace.
-     * Default is a folder with the same name as the component in the project root.
+     * The path where the component files should be created, relative to the current workspace.
+     * If not provided, a folder with the same name as the component will be created in the
+     * project's `src/app` directory.
      */
     path?: string;
     /**
-     * The prefix to apply to the generated component selector.
+     * A prefix to be added to the component's selector. For example, if the prefix is `app` and
+     * the component name is `my-component`, the selector will be `app-my-component`.
      */
     prefix?: string;
     /**
-     * The name of the project.
+     * The name of the project where the component should be added. If not specified, the CLI
+     * will determine the project from the current directory.
      */
     project: string;
     /**
-     * The HTML selector to use for this component.
+     * The HTML selector to use for this component. If not provided, a selector will be
+     * generated based on the component name (e.g., `app-my-component`).
      */
     selector?: string;
     /**
-     * Do not import this component into the owning NgModule.
+     * Do not automatically import the new component into its closest NgModule.
      */
     skipImport?: boolean;
     /**
-     * Specifies if the component should have a selector or not.
+     * Skip the generation of an HTML selector for the component.
      */
     skipSelector?: boolean;
     /**
-     * Do not create "spec.ts" test files for the new component.
+     * Skip the generation of unit test files `spec.ts`.
      */
     skipTests?: boolean;
     /**
-     * Whether the generated component is standalone.
+     * Generate a standalone component. Standalone components are self-contained and don't need
+     * to be declared in an NgModule. They can be used independently or imported directly into
+     * other standalone components.
      */
     standalone?: boolean;
     /**
-     * The file extension or preprocessor to use for style files, or 'none' to skip generating
-     * the style file.
+     * Specify the type of stylesheet to be created for the component, or `none` to skip
+     * creating a stylesheet.
      */
     style?: SchematicsAngularComponentStyle;
     /**
-     * Adds a developer-defined type to the filename, in the format "name.type.ts".
+     * Append a custom type to the component's filename. For example, if you set the type to
+     * `container`, the file will be named `my-component.container.ts`.
      */
     type?: string;
     /**
-     * The view encapsulation strategy to use in the new component.
+     * Sets the view encapsulation mode for the component. This determines how the component's
+     * styles are scoped and applied.
      */
     viewEncapsulation?: ViewEncapsulation;
 }
 /**
- * The change detection strategy to use in the new component.
+ * Configures the change detection strategy for the component.
  */
 export declare enum ChangeDetection {
     Default = "Default",
     OnPush = "OnPush"
 }
 /**
- * The file extension or preprocessor to use for style files, or 'none' to skip generating
- * the style file.
+ * Specify the type of stylesheet to be created for the component, or `none` to skip
+ * creating a stylesheet.
  */
 export declare enum SchematicsAngularComponentStyle {
     Css = "css",
@@ -333,108 +378,134 @@ export declare enum SchematicsAngularComponentStyle {
     Scss = "scss"
 }
 /**
- * Creates a new, generic directive definition in the given project.
+ * Creates a new directive in your project. Directives are used to extend the behavior or
+ * appearance of HTML elements and components. They allow you to manipulate the DOM, add
+ * custom attributes, and respond to events. This schematic generates the necessary files
+ * and boilerplate code for a new directive.
  */
 export interface AngularDirectiveOptionsSchema {
     /**
-     * The declaring NgModule exports this directive.
+     * Automatically export the directive from the specified NgModule, making it accessible to
+     * other modules in the application.
      */
     export?: boolean;
     /**
-     * When true (the default), creates the new files at the top level of the current project.
+     * Creates the new directive files at the top level of the current project. If set to false,
+     * a new folder with the directive's name will be created to contain the files.
      */
     flat?: boolean;
     /**
-     * The declaring NgModule.
+     * Specify the NgModule where the directive should be declared. If not provided, the CLI
+     * will attempt to find the closest NgModule in the directive's path.
      */
     module?: string;
     /**
-     * The name of the new directive.
+     * The name for the new directive. This will be used to create the directive's class and
+     * spec files (e.g., `my-directive.directive.ts` and `my-directive.directive.spec.ts`).
      */
     name: string;
     /**
-     * The path at which to create the interface that defines the directive, relative to the
-     * workspace root.
+     * The path where the directive files should be created, relative to the workspace root. If
+     * not provided, the directive will be created in the current directory.
      */
     path?: string;
     /**
-     * A prefix to apply to generated selectors.
+     * A prefix to be added to the directive's selector. For example, if the prefix is `app` and
+     * the directive name is `highlight`, the selector will be `appHighlight`.
      */
     prefix?: string;
     /**
-     * The name of the project.
+     * The name of the project where the directive should be added. If not specified, the CLI
+     * will determine the project from the current directory.
      */
     project: string;
     /**
-     * The HTML selector to use for this directive.
+     * The HTML selector to use for this directive. If not provided, a selector will be
+     * generated based on the directive's name (e.g., `appHighlight`).
      */
     selector?: string;
     /**
-     * Do not import this directive into the owning NgModule.
+     * Do not automatically import the new directive into its closest NgModule.
      */
     skipImport?: boolean;
     /**
-     * Do not create "spec.ts" test files for the new class.
+     * Skip the generation of a unit test file `spec.ts` for the new directive.
      */
     skipTests?: boolean;
     /**
-     * Whether the generated directive is standalone.
+     * Generate a standalone directive. Standalone directives are self-contained and don't need
+     * to be declared in an NgModule. They can be used independently or imported directly into
+     * other standalone components or directives.
      */
     standalone?: boolean;
 }
 /**
- * Generates a new, generic enum definition in the given project.
+ * Creates a new enum in your project. Enums (enumerations) are a way to define a set of
+ * named constants, making your code more readable and maintainable. This schematic
+ * generates a new enum with the specified name and type.
  */
 export interface AngularEnumOptionsSchema {
     /**
-     * The name of the enum.
+     * The name for the new enum. This will be used to create the enum file (e.g.,
+     * `my-enum.enum.ts`).
      */
     name: string;
     /**
-     * The path at which to create the enum definition, relative to the current workspace.
+     * The path where the enum file should be created, relative to the current workspace. If not
+     * specified, the enum will be created in the current directory.
      */
     path?: string;
     /**
-     * The name of the project in which to create the enum. Default is the configured default
-     * project for the workspace.
+     * The name of the project where the enum should be created. If not specified, the CLI will
+     * determine the project from the current directory.
      */
     project: string;
     /**
-     * Adds a developer-defined type to the filename, in the format "name.type.ts".
+     * Adds a custom type to the filename, allowing you to create more descriptive enum names.
+     * For example, if you set the type to `status`, the filename will be `my-enum.status.ts`.
      */
     type?: string;
 }
 /**
- * Generates a new, generic route guard definition in the given project.
+ * Creates a new route guard in your project. Route guards are used to control access to
+ * parts of your application by checking certain conditions before a route is activated.
+ * This schematic generates a new guard with the specified name, type, and options.
  */
 export interface AngularGuardOptionsSchema {
     /**
-     * When true (the default), creates the new files at the top level of the current project.
+     * Creates the new guard files at the top level of the current project. If set to false, a
+     * new folder with the guard's name will be created to contain the files.
      */
     flat?: boolean;
     /**
-     * Specifies whether to generate a guard as a function.
+     * Generate the guard as a function instead of a class. Functional guards can be simpler for
+     * basic scenarios.
      */
     functional?: boolean;
     /**
-     * Specifies which type of guard to create.
+     * Specifies the type(s) of guard to create. You can choose one or more of the following:
+     * `CanActivate` (controls access to a route), `CanActivateChild` (controls access to child
+     * routes), `CanDeactivate` (asks for confirmation before leaving a route), `CanMatch`
+     * (determines if a route can be matched).
      */
     implements?: Implement[];
     /**
-     * The name of the new route guard.
+     * The name for the new route guard. This will be used to create the guard's class and spec
+     * files (e.g., `my-guard.guard.ts` and `my-guard.guard.spec.ts`).
      */
     name: string;
     /**
-     * The path at which to create the interface that defines the guard, relative to the current
-     * workspace.
+     * The path where the guard files should be created, relative to the current workspace. If
+     * not provided, the guard will be created in the current directory.
      */
     path?: string;
     /**
-     * The name of the project.
+     * The name of the project where the guard should be created. If not specified, the CLI will
+     * determine the project from the current directory.
      */
     project: string;
     /**
-     * Do not create "spec.ts" test files for the new guard.
+     * Skip the generation of a unit test file `spec.ts` for the new guard.
      */
     skipTests?: boolean;
 }
@@ -445,139 +516,177 @@ export declare enum Implement {
     CanMatch = "CanMatch"
 }
 /**
- * Creates a new, generic interceptor definition in the given project.
+ * Creates a new interceptor in your project. Interceptors are used to intercept and modify
+ * HTTP requests and responses before they reach their destination. This allows you to
+ * perform tasks like adding authentication headers, handling errors, or logging requests.
+ * This schematic generates the necessary files and boilerplate code for a new interceptor.
  */
 export interface AngularInterceptorOptionsSchema {
     /**
-     * When true (the default), creates files at the top level of the project.
+     * Creates the new interceptor files at the top level of the current project. If set to
+     * false, a new folder with the interceptor's name will be created to contain the files.
      */
     flat?: boolean;
     /**
-     * Creates the interceptor as a `HttpInterceptorFn`.
+     * Creates the interceptor as a function `HttpInterceptorFn` instead of a class. Functional
+     * interceptors can be simpler for basic scenarios.
      */
     functional?: boolean;
     /**
-     * The name of the interceptor.
+     * The name for the new interceptor. This will be used to create the interceptor's class and
+     * spec files (e.g., `my-interceptor.interceptor.ts` and
+     * `my-interceptor.interceptor.spec.ts`).
      */
     name: string;
     /**
-     * The path at which to create the interceptor, relative to the workspace root.
+     * The path where the interceptor files should be created, relative to the workspace root.
+     * If not provided, the interceptor will be created in the current directory.
      */
     path?: string;
     /**
-     * The name of the project.
+     * The name of the project where the interceptor should be created. If not specified, the
+     * CLI will determine the project from the current directory.
      */
     project: string;
     /**
-     * Do not create "spec.ts" test files for the new interceptor.
+     * Skip the generation of a unit test file `spec.ts` for the new interceptor.
      */
     skipTests?: boolean;
 }
 /**
- * Creates a new, generic interface definition in the given project.
+ * Creates a new interface in your project. Interfaces define the structure of objects in
+ * TypeScript, ensuring type safety and code clarity. This schematic generates a new
+ * interface with the specified name and type.
  */
 export interface AngularInterfaceOptionsSchema {
     /**
-     * The name of the interface.
+     * The name for the new interface. This will be used to create the interface file (e.g.,
+     * `my-interface.interface.ts`).
      */
     name: string;
     /**
-     * The path at which to create the interface, relative to the workspace root.
+     * The path where the interface file should be created, relative to the workspace root. If
+     * not provided, the interface will be created in the current directory.
      */
     path?: string;
     /**
-     * A prefix to apply to generated selectors.
+     * A prefix to be added to the interface name. This is typically not used for interfaces, as
+     * they don't have selectors like components or directives.
      */
     prefix?: string;
     /**
-     * The name of the project.
+     * The name of the project where the interface should be created. If not specified, the CLI
+     * will determine the project from the current directory.
      */
     project: string;
     /**
-     * Adds a developer-defined type to the filename, in the format "name.type.ts".
+     * Adds a custom type to the filename, allowing you to create more descriptive interface
+     * names. For example, if you set the type to `data`, the filename will be
+     * `my-interface.data.ts`.
      */
     type?: string;
 }
 /**
- * Creates a new, generic library project in the current workspace.
+ * Creates a new library project in your Angular workspace. Libraries are reusable
+ * collections of components, services, and other Angular artifacts that can be shared
+ * across multiple applications. This schematic simplifies the process of generating a new
+ * library with the necessary files and configurations.
  */
 export interface LibraryOptionsSchema {
     /**
-     * The path at which to create the library's public API file, relative to the workspace root.
+     * The path to the library's public API file, relative to the workspace root. This file
+     * defines what parts of the library are accessible to applications that import it.
      */
     entryFile?: string;
     /**
-     * The name of the library.
+     * The name for the new library. This name will be used for the project directory and
+     * various identifiers within the library's code.
      */
     name: string;
     /**
-     * A prefix to apply to generated selectors.
+     * A prefix to be added to the selectors of components generated within this library. For
+     * example, if the prefix is `my-lib` and you generate a component named `my-component`, the
+     * selector will be `my-lib-my-component`.
      */
     prefix?: string;
     /**
-     * The root directory of the new library.
+     * The root directory for the new library, relative to the workspace root. If not specified,
+     * the library will be created in a subfolder within the `projects` directory, using the
+     * library's name.
      */
     projectRoot?: string;
     /**
-     * Do not install dependency packages.
+     * Skip the automatic installation of packages. You will need to manually install the
+     * dependencies later.
      */
     skipInstall?: boolean;
     /**
-     * Do not add dependencies to the "package.json" file.
+     * Do not automatically add dependencies to the `package.json` file.
      */
     skipPackageJson?: boolean;
     /**
-     * Do not update "tsconfig.json" to add a path mapping for the new library. The path mapping
-     * is needed to use the library in an app, but can be disabled here to simplify development.
+     * Do not update the workspace `tsconfig.json` file to add a path mapping for the new
+     * library. The path mapping is needed to use the library in an application, but can be
+     * disabled here to simplify development.
      */
     skipTsConfig?: boolean;
     /**
-     * Creates a library based upon the standalone API, without NgModules.
+     * Create a library that utilizes the standalone API, eliminating the need for NgModules.
+     * This can simplify the structure of your library and its usage in applications.
      */
     standalone?: boolean;
 }
 /**
- * Creates a new project by combining the workspace and application schematics.
+ * Creates a new Angular workspace and an initial project. This schematic sets up the
+ * foundation for your Angular development, generating the workspace configuration files and
+ * an optional starter application. You can customize various aspects of the workspace and
+ * the initial project, such as routing, styling, and testing.
  */
 export interface AngularNgNewOptionsSchema {
     /**
-     * Initial git repository commit information.
+     * Configure the initial Git commit for the new repository.
      */
     commit?: CommitUnion;
     /**
-     * Create a new initial application project in the 'src' folder of the new workspace. When
-     * false, creates an empty workspace with no initial application. You can then use the
-     * generate application command so that all applications are created in the projects folder.
+     * Create a new initial application project in the new workspace. When false, creates an
+     * empty workspace with no initial application. You can then use the `ng generate
+     * application` command to create applications in the `projects` directory.
      */
     createApplication?: boolean;
     /**
-     * The directory name to create the workspace in.
+     * The directory where the new workspace and project should be created. If not specified,
+     * the workspace will be created in the current directory.
      */
     directory?: string;
     /**
-     * Create an application that does not utilize zone.js.
+     * Create an initial application that does not utilize `zone.js`.
      */
     experimentalZoneless?: boolean;
     /**
-     * Include styles inline in the component TS file. By default, an external styles file is
-     * created and referenced in the component TypeScript file.
+     * Include the styles for the initial application's root component directly within the
+     * `app.component.ts` file. By default, a separate stylesheet file (e.g.,
+     * `app.component.css`) is created.
      */
     inlineStyle?: boolean;
     /**
-     * Include template inline in the component TS file. By default, an external template file
-     * is created and referenced in the component TypeScript file.
+     * Include the HTML template for the initial application's root component directly within
+     * the `app.component.ts` file. By default, a separate template file (e.g.,
+     * `app.component.html`) is created.
      */
     inlineTemplate?: boolean;
     /**
-     * Create a workspace without any testing frameworks. (Use for learning purposes only.)
+     * Generate a minimal Angular workspace without any testing frameworks. This is intended for
+     * learning purposes and simple experimentation, not for production applications.
      */
     minimal?: boolean;
     /**
-     * The name of the new workspace and initial project.
+     * The name for the new workspace and the initial project. This name will be used for the
+     * root directory and various identifiers throughout the project.
      */
     name: string;
     /**
-     * The path where new projects will be created, relative to the new workspace root.
+     * The path where new projects will be created within the workspace, relative to the
+     * workspace root. By default, new projects are created in the `projects` directory.
      */
     newProjectRoot?: string;
     /**
@@ -585,33 +694,38 @@ export interface AngularNgNewOptionsSchema {
      */
     packageManager?: PackageManager;
     /**
-     * The prefix to apply to generated selectors for the initial project.
+     * The prefix to apply to generated selectors for the initial project. For example, if the
+     * prefix is `my-app` and you generate a component named `my-component`, the selector will
+     * be `my-app-my-component`.
      */
     prefix?: string;
     /**
-     * Enable routing in the initial project.
+     * Enable routing in the initial application project. This sets up the necessary files and
+     * modules for managing navigation between different views in your application.
      */
     routing?: boolean;
     /**
-     * Creates a server application using the Server Routing and App Engine APIs (Developer
-     * Preview).
+     * Create a server application in the initial project using the Server Routing and App
+     * Engine APIs (Developer Preview).
      */
     serverRouting?: boolean;
     /**
-     * Do not initialize a git repository.
+     * Do not initialize a Git repository in the new workspace. By default, a Git repository is
+     * initialized to help you track changes to your project.
      */
     skipGit?: boolean;
     /**
-     * Do not install dependency packages.
+     * Skip the automatic installation of packages. You will need to manually install the
+     * dependencies later.
      */
     skipInstall?: boolean;
     /**
-     * Do not generate "spec.ts" test files for the new project.
+     * Skip the generation of unit test files `spec.ts`.
      */
     skipTests?: boolean;
     /**
-     * Creates an application with Server-Side Rendering (SSR) and Static Site Generation
-     * (SSG/Prerendering) enabled.
+     * Configure the initial application for Server-Side Rendering (SSR) and Static Site
+     * Generation (SSG/Prerendering).
      */
     ssr?: boolean;
     /**
@@ -619,13 +733,13 @@ export interface AngularNgNewOptionsSchema {
      */
     standalone?: boolean;
     /**
-     * Creates a workspace with stricter type checking and stricter bundle budgets settings.
-     * This setting helps improve maintainability and catch bugs ahead of time. For more
-     * information, see https://angular.dev/tools/cli/template-typecheck#strict-mode
+     * Enable stricter type checking and stricter bundle budgets settings. This setting helps
+     * improve maintainability and catch bugs ahead of time. For more information, see
+     * https://angular.dev/tools/cli/template-typecheck#strict-mode
      */
     strict?: boolean;
     /**
-     * The file extension or preprocessor to use for style files.
+     * The type of stylesheet files to be created for components in the initial project.
      */
     style?: SchematicsAngularApplicationStyle;
     /**
@@ -633,12 +747,15 @@ export interface AngularNgNewOptionsSchema {
      */
     version: string;
     /**
-     * The view encapsulation strategy to use in the initial project.
+     * Sets the view encapsulation mode for components in the initial project. This determines
+     * how component styles are scoped and applied. Options include: `Emulated` (default, styles
+     * are scoped to the component), `None` (styles are global), and `ShadowDom` (styles are
+     * encapsulated using Shadow DOM).
      */
     viewEncapsulation?: ViewEncapsulation;
 }
 /**
- * Initial git repository commit information.
+ * Configure the initial Git commit for the new repository.
  */
 export type CommitUnion = boolean | CommitObject;
 export interface CommitObject {
@@ -648,119 +765,149 @@ export interface CommitObject {
     [property: string]: any;
 }
 /**
- * Creates a new, generic pipe definition in the given project.
+ * Creates a new pipe in your project. Pipes are used to transform data for display in
+ * templates. They take input values and apply a specific transformation, such as formatting
+ * dates, currency, or filtering arrays. This schematic generates the necessary files and
+ * boilerplate code for a new pipe.
  */
 export interface AngularPipeOptionsSchema {
     /**
-     * The declaring NgModule exports this pipe.
+     * Automatically export the pipe from the specified NgModule, making it accessible to other
+     * modules in the application.
      */
     export?: boolean;
     /**
-     * When true (the default) creates files at the top level of the project.
+     * Creates the new pipe files at the top level of the current project. If set to false, a
+     * new folder with the pipe's name will be created to contain the files.
      */
     flat?: boolean;
     /**
-     * The declaring NgModule.
+     * Specify the NgModule where the pipe should be declared. If not provided, the CLI will
+     * attempt to find the closest NgModule in the pipe's path.
      */
     module?: string;
     /**
-     * The name of the pipe.
+     * The name for the new pipe. This will be used to create the pipe's class and spec files
+     * (e.g., `my-pipe.pipe.ts` and `my-pipe.pipe.spec.ts`).
      */
     name: string;
     /**
-     * The path at which to create the pipe, relative to the workspace root.
+     * The path where the pipe files should be created, relative to the workspace root. If not
+     * provided, the pipe will be created in the current directory.
      */
     path?: string;
     /**
-     * The name of the project.
+     * The name of the project where the pipe should be created. If not specified, the CLI will
+     * determine the project from the current directory.
      */
     project: string;
     /**
-     * Do not import this pipe into the owning NgModule.
+     * Do not automatically import the new pipe into its closest NgModule.
      */
     skipImport?: boolean;
     /**
-     * Do not create "spec.ts" test files for the new pipe.
+     * Prevent the generation of a unit test file `spec.ts` for the new pipe.
      */
     skipTests?: boolean;
     /**
-     * Whether the generated pipe is standalone.
+     * Generate a standalone pipe. Standalone pipes are self-contained and don't need to be
+     * declared in an NgModule. They can be used independently or imported directly into other
+     * standalone components, directives, or pipes.
      */
     standalone?: boolean;
 }
 /**
- * Generates a new, generic resolver definition in the given project.
+ * Creates a new resolver in your project. Resolvers are used to pre-fetch data before a
+ * route is activated, ensuring that the necessary data is available before the component is
+ * displayed. This can improve the user experience by preventing delays and loading states.
+ * This schematic generates a new resolver with the specified name and options.
  */
 export interface AngularResolverOptionsSchema {
     /**
-     * When true (the default), creates the new files at the top level of the current project.
+     * Creates the new resolver files at the top level of the current project. If set to false,
+     * a new folder with the resolver's name will be created to contain the files.
      */
     flat?: boolean;
     /**
-     * Creates the resolver as a `ResolveFn`.
+     * Creates the resolver as a function `ResolveFn` instead of a class. Functional resolvers
+     * can be simpler for basic scenarios.
      */
     functional?: boolean;
     /**
-     * The name of the new resolver.
+     * The name for the new resolver. This will be used to create the resolver's class and spec
+     * files (e.g., `my-resolver.resolver.ts` and `my-resolver.resolver.spec.ts`).
      */
     name: string;
     /**
-     * The path at which to create the interface that defines the resolver, relative to the
-     * current workspace.
+     * The path where the resolver files should be created, relative to the current workspace.
+     * If not provided, the resolver will be created in the current directory.
      */
     path?: string;
     /**
-     * The name of the project.
+     * The name of the project where the resolver should be created. If not specified, the CLI
+     * will determine the project from the current directory.
      */
     project: string;
     /**
-     * Do not create "spec.ts" test files for the new resolver.
+     * Skip the generation of a unit test file `spec.ts` for the new resolver.
      */
     skipTests?: boolean;
 }
 /**
- * Creates a new, generic service definition in the given project.
+ * Creates a new service in your project. Services are used to encapsulate reusable logic,
+ * such as data access, API calls, or utility functions. This schematic simplifies the
+ * process of generating a new service with the necessary files and boilerplate code.
  */
 export interface AngularServiceOptionsSchema {
     /**
-     * When true (the default), creates files at the top level of the project.
+     * Creates files at the top level of the project or the given path. If set to false, a new
+     * folder with the service's name will be created to contain the files.
      */
     flat?: boolean;
     /**
-     * The name of the service.
+     * The name for the new service. This will be used to create the service's class and spec
+     * files (e.g., `my-service.service.ts` and `my-service.service.spec.ts`).
      */
     name: string;
     /**
-     * The path at which to create the service, relative to the workspace root.
+     * The path where the service files should be created, relative to the workspace root. If
+     * not provided, the service will be created in the project's `src/app` directory.
      */
     path?: string;
     /**
-     * The name of the project.
+     * The name of the project where the service should be added. If not specified, the CLI will
+     * determine the project from the current directory.
      */
     project: string;
     /**
-     * Do not create "spec.ts" test files for the new service.
+     * Skip the generation of a unit test file `spec.ts` for the service.
      */
     skipTests?: boolean;
 }
 /**
- * Creates a new, generic web worker definition in the given project.
+ * Creates a new web worker in your project. Web workers allow you to run JavaScript code in
+ * the background, improving the performance and responsiveness of your application by
+ * offloading computationally intensive tasks. This schematic generates the necessary files
+ * for a new web worker and provides an optional code snippet to demonstrate its usage.
  */
 export interface AngularWebWorkerOptionsSchema {
     /**
-     * The name of the worker.
+     * The name for the new web worker. This will be used to create the worker file (e.g.,
+     * `my-worker.worker.ts`).
      */
     name: string;
     /**
-     * The path at which to create the worker file, relative to the current workspace.
+     * The path where the web worker file should be created, relative to the current workspace.
+     * If not specified, the worker will be created in the current directory.
      */
     path?: string;
     /**
-     * The name of the project.
+     * The name of the project where the web worker should be created. If not specified, the CLI
+     * will determine the project from the current directory.
      */
     project: string;
     /**
-     * Add a worker creation snippet in a sibling file of the same name.
+     * Generate a code snippet that demonstrates how to create and use the new web worker.
      */
     snippet?: boolean;
 }