@depup/angular__cli 21.2.1-depup.1

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

@@ -0,0 +1,1025 @@
+export type Schema = {
+    $schema?: string;
+    cli?: CliOptions;
+    /**
+     * Path where new projects will be created.
+     */
+    newProjectRoot?: string;
+    projects?: Projects;
+    schematics?: SchematicOptions;
+    version: number;
+};
+export type CliOptions = {
+    /**
+     * Share pseudonymous usage data with the Angular Team at Google.
+     */
+    analytics?: Analytics;
+    /**
+     * Control disk cache.
+     */
+    cache?: Cache;
+    /**
+     * Specify which package manager tool to use.
+     */
+    packageManager?: PackageManager;
+    /**
+     * The list of schematic collections to use.
+     */
+    schematicCollections?: string[];
+    /**
+     * Control CLI specific console warnings
+     */
+    warnings?: Warnings;
+};
+/**
+ * Share pseudonymous usage data with the Angular Team at Google.
+ */
+export type Analytics = boolean | string;
+/**
+ * Control disk cache.
+ */
+export type Cache = {
+    /**
+     * Configure whether disk caching is enabled.
+     */
+    enabled?: boolean;
+    /**
+     * Configure in which environment disk cache is enabled.
+     */
+    environment?: Environment;
+    /**
+     * Cache base path.
+     */
+    path?: string;
+};
+/**
+ * Configure in which environment disk cache is enabled.
+ */
+export declare enum Environment {
+    All = "all",
+    Ci = "ci",
+    Local = "local"
+}
+/**
+ * Specify which package manager tool to use.
+ *
+ * The package manager used to install dependencies.
+ */
+export declare enum PackageManager {
+    Bun = "bun",
+    Npm = "npm",
+    Pnpm = "pnpm",
+    Yarn = "yarn"
+}
+/**
+ * Control CLI specific console warnings
+ */
+export type Warnings = {
+    /**
+     * Show a warning when the global version is newer than the local one.
+     */
+    versionMismatch?: boolean;
+};
+export type Projects = {};
+export type SchematicOptions = {
+    "@schematics/angular:application"?: AngularApplicationOptionsSchema;
+    "@schematics/angular:class"?: AngularClassOptionsSchema;
+    "@schematics/angular:component"?: AngularComponentOptionsSchema;
+    "@schematics/angular:directive"?: AngularDirectiveOptionsSchema;
+    "@schematics/angular:enum"?: AngularEnumOptionsSchema;
+    "@schematics/angular:guard"?: AngularGuardOptionsSchema;
+    "@schematics/angular:interceptor"?: AngularInterceptorOptionsSchema;
+    "@schematics/angular:interface"?: AngularInterfaceOptionsSchema;
+    "@schematics/angular:library"?: LibraryOptionsSchema;
+    "@schematics/angular:ng-new"?: AngularNgNewOptionsSchema;
+    "@schematics/angular:pipe"?: AngularPipeOptionsSchema;
+    "@schematics/angular:resolver"?: AngularResolverOptionsSchema;
+    "@schematics/angular:service"?: AngularServiceOptionsSchema;
+    "@schematics/angular:web-worker"?: AngularWebWorkerOptionsSchema;
+    [property: string]: any;
+};
+/**
+ * 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 type AngularApplicationOptionsSchema = {
+    /**
+     * The file naming convention to use for generated files. The '2025' style guide (default)
+     * uses a concise format (e.g., `app.ts` for the root component), while the '2016' style
+     * guide includes the type in the file name (e.g., `app.component.ts`). For more
+     * information, see the Angular Style Guide (https://angular.dev/style-guide).
+     */
+    fileNameStyleGuide?: FileNameStyleGuide;
+    /**
+     * 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 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;
+    /**
+     * 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 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 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 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;
+    /**
+     * 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;
+    /**
+     * 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.
+     */
+    skipPackageJson?: boolean;
+    /**
+     * Skip the generation of a unit test files `spec.ts`.
+     */
+    skipTests?: boolean;
+    /**
+     * Configure the application for Server-Side Rendering (SSR) and Static Site Generation
+     * (SSG/Prerendering).
+     */
+    ssr?: boolean;
+    /**
+     * Create an application that utilizes the standalone API, eliminating the need for
+     * NgModules. This can simplify the structure of your application.
+     */
+    standalone?: boolean;
+    /**
+     * 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 type of stylesheet files to be created for components in the application.
+     */
+    style?: SchematicsAngularApplicationStyle;
+    /**
+     * The unit testing runner to use.
+     */
+    testRunner?: TestRunner;
+    /**
+     * Sets the view encapsulation mode for the application's components. This determines how
+     * component styles are scoped and applied.
+     */
+    viewEncapsulation?: ViewEncapsulation;
+    /**
+     * Generate an application that does not use `zone.js`.
+     */
+    zoneless?: boolean;
+};
+/**
+ * The file naming convention to use for generated files. The '2025' style guide (default)
+ * uses a concise format (e.g., `app.ts` for the root component), while the '2016' style
+ * guide includes the type in the file name (e.g., `app.component.ts`). For more
+ * information, see the Angular Style Guide (https://angular.dev/style-guide).
+ */
+export declare enum FileNameStyleGuide {
+    The2016 = "2016",
+    The2025 = "2025"
+}
+/**
+ * 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",
+    Less = "less",
+    Sass = "sass",
+    Scss = "scss",
+    Tailwind = "tailwind"
+}
+/**
+ * The unit testing runner to use.
+ */
+export declare enum TestRunner {
+    Karma = "karma",
+    Vitest = "vitest"
+}
+/**
+ * Sets the view encapsulation mode for the application's components. This determines how
+ * component styles are scoped and applied.
+ *
+ * Sets the view encapsulation mode for the component. This determines how the component's
+ * styles are scoped and applied.
+ *
+ * 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",
+    None = "None",
+    ShadowDom = "ShadowDom"
+}
+/**
+ * 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 type AngularClassOptionsSchema = {
+    /**
+     * 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 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 where the class should be added. If not specified, the CLI will
+     * determine the project from the current directory.
+     */
+    project: string;
+    /**
+     * Skip the generation of a unit test file `spec.ts` for the new class.
+     */
+    skipTests?: boolean;
+    /**
+     * 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 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 type AngularComponentOptionsSchema = {
+    /**
+     * When true, the 'type' option will be appended to the generated class name. When false,
+     * only the file name will include the type.
+     */
+    addTypeToClassName?: boolean;
+    /**
+     * Configures the change detection strategy for the component.
+     */
+    changeDetection?: ChangeDetection;
+    /**
+     * 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;
+    /**
+     * Automatically export the component from the specified NgModule, making it accessible to
+     * other modules in the application.
+     */
+    export?: boolean;
+    /**
+     * Use a default export for the component in its TypeScript file instead of a named export.
+     */
+    exportDefault?: boolean;
+    /**
+     * Create the component files directly in the project's `src/app` directory instead of
+     * creating a new folder for them.
+     */
+    flat?: boolean;
+    /**
+     * Include the component's styles directly in the `component.ts` file. By default, a
+     * separate stylesheet file (e.g., `my-component.css`) is created.
+     */
+    inlineStyle?: boolean;
+    /**
+     * Include the component's HTML template directly in the `component.ts` file. By default, a
+     * separate template file (e.g., `my-component.html`) is created.
+     */
+    inlineTemplate?: boolean;
+    /**
+     * 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 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.ts`, `my-component.html`, and `my-component.css`.
+     */
+    name: string;
+    /**
+     * Generate component template files with an '.ng.html' file extension instead of '.html'.
+     */
+    ngHtml?: boolean;
+    /**
+     * 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;
+    /**
+     * 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 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. If not provided, a selector will be
+     * generated based on the component name (e.g., `app-my-component`).
+     */
+    selector?: string;
+    /**
+     * Do not automatically import the new component into its closest NgModule.
+     */
+    skipImport?: boolean;
+    /**
+     * Skip the generation of an HTML selector for the component.
+     */
+    skipSelector?: boolean;
+    /**
+     * Skip the generation of unit test files `spec.ts`.
+     */
+    skipTests?: boolean;
+    /**
+     * 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;
+    /**
+     * Specify the type of stylesheet to be created for the component, or `none` to skip
+     * creating a stylesheet.
+     */
+    style?: SchematicsAngularComponentStyle;
+    /**
+     * 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;
+    /**
+     * Sets the view encapsulation mode for the component. This determines how the component's
+     * styles are scoped and applied.
+     */
+    viewEncapsulation?: ViewEncapsulation;
+};
+/**
+ * Configures the change detection strategy for the component.
+ */
+export declare enum ChangeDetection {
+    Default = "Default",
+    OnPush = "OnPush"
+}
+/**
+ * Specify the type of stylesheet to be created for the component, or `none` to skip
+ * creating a stylesheet.
+ */
+export declare enum SchematicsAngularComponentStyle {
+    Css = "css",
+    Less = "less",
+    None = "none",
+    Sass = "sass",
+    Scss = "scss"
+}
+/**
+ * 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 type AngularDirectiveOptionsSchema = {
+    /**
+     * When true, the 'type' option will be appended to the generated class name. When false,
+     * only the file name will include the type.
+     */
+    addTypeToClassName?: boolean;
+    /**
+     * Automatically export the directive from the specified NgModule, making it accessible to
+     * other modules in the application.
+     */
+    export?: boolean;
+    /**
+     * 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;
+    /**
+     * 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 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 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 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 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. If not provided, a selector will be
+     * generated based on the directive's name (e.g., `appHighlight`).
+     */
+    selector?: string;
+    /**
+     * Do not automatically import the new directive into its closest NgModule.
+     */
+    skipImport?: boolean;
+    /**
+     * Skip the generation of a unit test file `spec.ts` for the new directive.
+     */
+    skipTests?: boolean;
+    /**
+     * 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;
+    /**
+     * Append a custom type to the directive's filename. For example, if you set the type to
+     * `directive`, the file will be named `example.directive.ts`.
+     */
+    type?: string;
+};
+/**
+ * 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 type AngularEnumOptionsSchema = {
+    /**
+     * 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 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 where the enum should be created. If not specified, the CLI will
+     * determine the project from the current directory.
+     */
+    project: string;
+    /**
+     * 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;
+};
+/**
+ * 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 type AngularGuardOptionsSchema = {
+    /**
+     * 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;
+    /**
+     * Generate the guard as a function instead of a class. Functional guards can be simpler for
+     * basic scenarios.
+     */
+    functional?: boolean;
+    /**
+     * 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 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 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 where the guard should be created. If not specified, the CLI will
+     * determine the project from the current directory.
+     */
+    project: string;
+    /**
+     * Skip the generation of a unit test file `spec.ts` for the new guard.
+     */
+    skipTests?: boolean;
+    /**
+     * The separator character to use before the type within the generated file's name. For
+     * example, if you set the option to `.`, the file will be named `example.guard.ts`.
+     */
+    typeSeparator?: TypeSeparator;
+};
+export declare enum Implement {
+    CanActivate = "CanActivate",
+    CanActivateChild = "CanActivateChild",
+    CanDeactivate = "CanDeactivate",
+    CanMatch = "CanMatch"
+}
+/**
+ * The separator character to use before the type within the generated file's name. For
+ * example, if you set the option to `.`, the file will be named `example.guard.ts`.
+ *
+ * The separator character to use before the type within the generated file's name. For
+ * example, if you set the option to `.`, the file will be named `example.interceptor.ts`.
+ *
+ * The separator character to use before the type within the generated file's name. For
+ * example, if you set the option to `.`, the file will be named `example.pipe.ts`.
+ *
+ * The separator character to use before the type within the generated file's name. For
+ * example, if you set the option to `.`, the file will be named `example.resolver.ts`.
+ */
+export declare enum TypeSeparator {
+    Empty = "-",
+    TypeSeparator = "."
+}
+/**
+ * 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 type AngularInterceptorOptionsSchema = {
+    /**
+     * 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 function `HttpInterceptorFn` instead of a class. Functional
+     * interceptors can be simpler for basic scenarios.
+     */
+    functional?: boolean;
+    /**
+     * 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 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 where the interceptor should be created. If not specified, the
+     * CLI will determine the project from the current directory.
+     */
+    project: string;
+    /**
+     * Skip the generation of a unit test file `spec.ts` for the new interceptor.
+     */
+    skipTests?: boolean;
+    /**
+     * The separator character to use before the type within the generated file's name. For
+     * example, if you set the option to `.`, the file will be named `example.interceptor.ts`.
+     */
+    typeSeparator?: TypeSeparator;
+};
+/**
+ * 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 type AngularInterfaceOptionsSchema = {
+    /**
+     * 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 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 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 where the interface should be created. If not specified, the CLI
+     * will determine the project from the current directory.
+     */
+    project: string;
+    /**
+     * 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 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 type LibraryOptionsSchema = {
+    /**
+     * 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 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 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 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;
+    /**
+     * Skip the automatic installation of packages. You will need to manually install the
+     * dependencies later.
+     */
+    skipInstall?: boolean;
+    /**
+     * Do not automatically add dependencies to the `package.json` file.
+     */
+    skipPackageJson?: boolean;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * The unit testing runner to use.
+     */
+    testRunner?: TestRunner;
+};
+/**
+ * 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 type AngularNgNewOptionsSchema = {
+    /**
+     * Specifies which AI tools to generate configuration files for. These file are used to
+     * improve the outputs of AI tools by following the best practices.
+     */
+    aiConfig?: AiConfig[];
+    /**
+     * Configure the initial Git commit for the new repository.
+     */
+    commit?: CommitUnion;
+    /**
+     * 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 where the new workspace and project should be created. If not specified,
+     * the workspace will be created in the current directory.
+     */
+    directory?: string;
+    /**
+     * The file naming convention to use for generated files. The '2025' style guide (default)
+     * uses a concise format (e.g., `app.ts` for the root component), while the '2016' style
+     * guide includes the type in the file name (e.g., `app.component.ts`). For more
+     * information, see the Angular Style Guide (https://angular.dev/style-guide).
+     */
+    fileNameStyleGuide?: FileNameStyleGuide;
+    /**
+     * 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 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;
+    /**
+     * 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 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 within the workspace, relative to the
+     * workspace root. By default, new projects are created in the `projects` directory.
+     */
+    newProjectRoot?: string;
+    /**
+     * The package manager used to install dependencies.
+     */
+    packageManager?: PackageManager;
+    /**
+     * 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 application project. This sets up the necessary files and
+     * modules for managing navigation between different views in your application.
+     */
+    routing?: boolean;
+    /**
+     * 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;
+    /**
+     * Skip the automatic installation of packages. You will need to manually install the
+     * dependencies later.
+     */
+    skipInstall?: boolean;
+    /**
+     * Skip the generation of unit test files `spec.ts`.
+     */
+    skipTests?: boolean;
+    /**
+     * Configure the initial application for Server-Side Rendering (SSR) and Static Site
+     * Generation (SSG/Prerendering).
+     */
+    ssr?: boolean;
+    /**
+     * Creates an application based upon the standalone API, without NgModules.
+     */
+    standalone?: boolean;
+    /**
+     * 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 type of stylesheet files to be created for components in the initial project.
+     */
+    style?: SchematicsAngularApplicationStyle;
+    /**
+     * The unit testing runner to use.
+     */
+    testRunner?: TestRunner;
+    /**
+     * The version of the Angular CLI to use.
+     */
+    version: string;
+    /**
+     * 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;
+    /**
+     * Create an initial application that does not utilize `zone.js`.
+     */
+    zoneless?: boolean;
+};
+export declare enum AiConfig {
+    Agents = "agents",
+    Claude = "claude",
+    Copilot = "copilot",
+    Cursor = "cursor",
+    Gemini = "gemini",
+    Jetbrains = "jetbrains",
+    None = "none",
+    Windsurf = "windsurf"
+}
+/**
+ * Configure the initial Git commit for the new repository.
+ */
+export type CommitUnion = boolean | CommitObject;
+export type CommitObject = {
+    email: string;
+    message?: string;
+    name: string;
+    [property: string]: any;
+};
+/**
+ * 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 type AngularPipeOptionsSchema = {
+    /**
+     * Automatically export the pipe from the specified NgModule, making it accessible to other
+     * modules in the application.
+     */
+    export?: boolean;
+    /**
+     * 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;
+    /**
+     * 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 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 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 where the pipe should be created. If not specified, the CLI will
+     * determine the project from the current directory.
+     */
+    project: string;
+    /**
+     * Do not automatically import the new pipe into its closest NgModule.
+     */
+    skipImport?: boolean;
+    /**
+     * Prevent the generation of a unit test file `spec.ts` for the new pipe.
+     */
+    skipTests?: boolean;
+    /**
+     * 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;
+    /**
+     * The separator character to use before the type within the generated file's name. For
+     * example, if you set the option to `.`, the file will be named `example.pipe.ts`.
+     */
+    typeSeparator?: TypeSeparator;
+};
+/**
+ * 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 type AngularResolverOptionsSchema = {
+    /**
+     * 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 function `ResolveFn` instead of a class. Functional resolvers
+     * can be simpler for basic scenarios.
+     */
+    functional?: boolean;
+    /**
+     * 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 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 where the resolver should be created. If not specified, the CLI
+     * will determine the project from the current directory.
+     */
+    project: string;
+    /**
+     * Skip the generation of a unit test file `spec.ts` for the new resolver.
+     */
+    skipTests?: boolean;
+    /**
+     * The separator character to use before the type within the generated file's name. For
+     * example, if you set the option to `.`, the file will be named `example.resolver.ts`.
+     */
+    typeSeparator?: TypeSeparator;
+};
+/**
+ * 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 type AngularServiceOptionsSchema = {
+    /**
+     * When true, the 'type' option will be appended to the generated class name. When false,
+     * only the file name will include the type.
+     */
+    addTypeToClassName?: boolean;
+    /**
+     * 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 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 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 where the service should be added. If not specified, the CLI will
+     * determine the project from the current directory.
+     */
+    project: string;
+    /**
+     * Skip the generation of a unit test file `spec.ts` for the service.
+     */
+    skipTests?: boolean;
+    /**
+     * Append a custom type to the service's filename. For example, if you set the type to
+     * `service`, the file will be named `my-service.service.ts`.
+     */
+    type?: string;
+};
+/**
+ * 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 type AngularWebWorkerOptionsSchema = {
+    /**
+     * 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 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 where the web worker should be created. If not specified, the CLI
+     * will determine the project from the current directory.
+     */
+    project: string;
+    /**
+     * Generate a code snippet that demonstrates how to create and use the new web worker.
+     */
+    snippet?: boolean;
+};