@nrwl/workspace

const stringUtils: typeof strings;

addDepsToPackageJson: (deps: any, devDeps: any, addInstall?: boolean) => Rule;

addGlobal: (
    source: ts.SourceFile,
    modulePath: string,
    statement: string
) => Change[];

addIncludeToTsConfig: (
    tsConfigPath: string,
    source: ts.SourceFile,
    include: string
) => Change[];

addInstallTask: (options?: { skipInstall: boolean }) => Rule;

addLintFiles: (
    projectRoot: string,
    linter: Linter,
    options?: AddLintFileOptions
) => Rule;

addMethod: (
    source: ts.SourceFile,
    modulePath: string,
    opts: { className: string; methodHeader: string; body: string }
) => Change[];

addPackageWithInit: (
    packageName: string,
    testRunners?: {
        unitTestRunner: 'jest' | 'none';
        e2eTestRunner?: 'cypress' | 'none';
    }
) => Rule;

addParameterToConstructor: (
    source: ts.SourceFile,
    modulePath: string,
    opts: { className: string; param: string }
) => Change[];

addUpdateTask: (pkg: string, to: string, dependencies?: TaskId[]) => Rule;

checkAndCleanWithSemver: (pkgName: string, version: string) => string;

convertToNxProjectGenerator: (host: Tree, schema: Schema) => Promise<void>;

convertToNxProjectSchematic: (
    generatorOptions: Schema
) => (tree: any, context: any) => Promise<any>;

copyFile: (file: string, target: string) => void;

createOrUpdate: (host: Tree, path: string, content: string) => void;

deleteFile: (from: string) => Rule;

editTarget: (targetString: string, callback: any) => string;

findNodes: (node: Node, kind: SyntaxKind | SyntaxKind[], max?: number) => Node[];

formatFiles: (options?: { skipFormat: boolean }, directory?: string) => Rule;

generateProjectLint: (
    projectRoot: string,
    tsConfigPath: string,
    linter: Linter,
    eslintFilePatterns: string[]
) => { builder: string; options: { lintFilePatterns: string[] } };

getNpmScope: (host: Tree) => string;

getProjectConfig: (host: Tree, name: string) => any;

getWorkspace: (
    tree: Tree,
    path?: string
) => Promise<workspaces.WorkspaceDefinition>;

getWorkspacePath: (host: Tree) => string;

insert: (host: Tree, modulePath: string, changes: Change[]) => void;

libraryGenerator: (tree: Tree, schema: Schema) => Promise<GeneratorCallback>;

moveGenerator: (tree: Tree, rawSchema: Schema) => Promise<void>;

parseTarget: (targetString: string) => {
    project: string;
    target: string;
    config: string;
};

projectRootDir: (projectType: ProjectType) => 'libs' | 'apps';

readJsonInTree: <T extends object = any>(host: Tree, path: string) => T;

readNxJsonInTree: (host: Tree) => NxJsonConfiguration<string[] | '*'>;

readTsConfig: (tsConfigPath: string) => any;

readWorkspace: (host: Tree) => any;

removeGenerator: (tree: Tree, schema: Schema) => Promise<void>;

renameDirSyncInTree: (
    tree: Tree,
    from: string,
    to: string,
    cb: (err: string) => void
) => void;

renameSync: (from: string, to: string, cb: (err: Error | null) => void) => void;

renameSyncInTree: (
    tree: Tree,
    from: string,
    to: string,
    cb: (err: string) => void
) => void;

replaceAppNameWithPath: (node: any, appName: string, root: string) => any;

replaceNodeValue: (
    host: Tree,
    modulePath: string,
    node: ts.Node,
    content: string
) => void;

resolveUserExistingPrettierConfig: () => Promise<ExistingPrettierConfig | null>;

runCommandsGenerator: (host: Tree, schema: Schema) => Promise<void>;

serializeTarget: ({
    project,
    target,
    config,
}: {
    project: any;
    target: any;
    config: any;
}) => string;

updateBuilderConfig: (
    updater: (
        currentValue: Record<
            string,
            string | number | boolean | JsonArray | JsonObject
        >,
        target?: TargetDefinition,
        project?: ProjectDefinition
    ) => Record<string, string | number | boolean | JsonArray | JsonObject>,
    ...builderNames: string[]
) => Rule;

updateJsonFile: (path: string, callback: (a: any) => any) => void;

updateJsonInTree: <T extends object = any, O extends object = T>(
    path: string,
    callback: (json: T, context: SchematicContext) => O
) => Rule;

updateKarmaConf: (options: { projectName: string }) => Rule;

updateNxJsonInTree: (
    callback: (
        json: NxJsonConfiguration,
        context: SchematicContext
    ) => NxJsonConfiguration
) => Rule;

updatePackageJsonDependencies: (
    deps: any,
    devDeps: any,
    addInstall?: boolean
) => Rule;

updatePackagesInPackageJson: (
    migrationFilePath: string,
    versionName: string,
    options?: { skipInstall: boolean }
) => any;

updateWorkspace: {
    (
        updater: (
            workspace: workspaces.WorkspaceDefinition
        ) => void | PromiseLike<void>
    ): Rule;
    (workspace: workspaces.WorkspaceDefinition): Rule;
};

updateWorkspaceInTree: <T extends object = any, O extends object = T>(
    callback: (json: T, context: SchematicContext, host: Tree) => O
) => Rule;

visitNotIgnoredFiles: (
    visitor: (file: Path, host: Tree, context: SchematicContext) => void | Rule,
    dir?: Path
) => Rule;