@angular/cdk 8.0.0-rc.2 → 8.1.0

package/typings/schematics/ng-update/data/property-names.d.ts

@@ -5,7 +5,7 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-import { VersionChanges } from '../upgrade-data';
+import { VersionChanges } from '../../update-tool/version-changes';
 export interface PropertyNameUpgradeData {
     /** The property name to replace. */
     replace: string;

package/typings/schematics/ng-update/index.d.ts

@@ -12,5 +12,3 @@ export declare function updateToV6(): Rule;
 export declare function updateToV7(): Rule;
 /** Entry point for the migration schematics with target of Angular Material 8.0.0 */
 export declare function updateToV8(): Rule;
-/** Post-update schematic to be called when update is finished. */
-export declare function postUpdate(): Rule;

package/typings/schematics/ng-update/public-api.d.ts

@@ -5,16 +5,11 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-export * from './target-version';
 export * from './upgrade-data';
 export * from './data/index';
 export * from './html-parsing/angular';
 export * from './html-parsing/elements';
 export * from './upgrade-rules/index';
-export * from './upgrade-rules/tslint-config';
-export * from './tslint/component-walker';
-export * from './tslint/component-file';
-export * from './tslint/external-failure-walker';
 export * from './typescript/base-types';
 export * from './typescript/imports';
 export * from './typescript/literal';

package/typings/schematics/ng-update/upgrade-data.d.ts

@@ -5,18 +5,11 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-import { RuleWalker } from 'tslint';
+import { MigrationRule } from '../update-tool/migration-rule';
+import { ValueOfChanges, VersionChanges } from '../update-tool/version-changes';
 import { AttributeSelectorUpgradeData, ClassNameUpgradeData, ConstructorChecksUpgradeData, CssSelectorUpgradeData, ElementSelectorUpgradeData, InputNameUpgradeData, MethodCallUpgradeData, OutputNameUpgradeData, PropertyNameUpgradeData } from './data';
-import { TargetVersion } from './target-version';
-export declare type VersionChanges<T> = {
-    [target in TargetVersion]?: ReadableChange<T>[];
-};
-export declare type ReadableChange<T> = {
-    pr: string;
-    changes: T[];
-};
-/** Conditional type that unwraps the value of a version changes type. */
-declare type ValueOfChanges<T> = T extends VersionChanges<infer X> ? X : null;
+/** Upgrade data for the Angular CDK. */
+export declare const cdkUpgradeData: RuleUpgradeData;
 /**
  * Interface that describes the upgrade data that needs to be defined when using the CDK
  * upgrade rules.
@@ -32,28 +25,10 @@ export interface RuleUpgradeData {
     outputNames: VersionChanges<OutputNameUpgradeData>;
     propertyNames: VersionChanges<PropertyNameUpgradeData>;
 }
-/** Upgrade data for the Angular CDK. */
-export declare const cdkUpgradeData: RuleUpgradeData;
-/**
- * Gets the changes for a given target version from the specified version changes object.
- *
- * For readability and a good overview of breaking changes, the version change data always
- * includes the related Pull Request link. Since this data is not needed when performing the
- * upgrade, this unused data can be removed and the changes data can be flattened into an
- * easy iterable array.
- */
-export declare function getChangesForTarget<T>(target: TargetVersion, data: VersionChanges<T>): T[];
-/**
- * Gets all changes from the specified version changes object. This is helpful in case a migration
- * rule does not distinguish data based on the target version, but for readability the
- * upgrade data is separated for each target version.
- */
-export declare function getAllChanges<T>(data: VersionChanges<T>): T[];
 /**
  * Gets the reduced upgrade data for the specified data key from the rule walker options.
  *
  * The function reads out the target version and upgrade data object from the rule options and
  * resolves the specified data portion that is specifically tied to the target version.
  */
-export declare function getUpgradeDataFromWalker<T extends keyof RuleUpgradeData, U = ValueOfChanges<RuleUpgradeData[T]>>(walker: RuleWalker, dataName: T): U[];
-export {};
+export declare function getVersionUpgradeData<T extends keyof RuleUpgradeData, U = ValueOfChanges<RuleUpgradeData[T]>>(r: MigrationRule<RuleUpgradeData>, dataName: T): U[];

package/typings/schematics/ng-update/upgrade-rules/attribute-selectors-rule.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import * as ts from 'typescript';
+import { ResolvedResource } from '../../update-tool/component-resource-collector';
+import { MigrationRule } from '../../update-tool/migration-rule';
+import { RuleUpgradeData } from '../upgrade-data';
+/**
+ * Migration rule that walks through every string literal, template and stylesheet
+ * in order to switch deprecated attribute selectors to the updated selector.
+ */
+export declare class AttributeSelectorsRule extends MigrationRule<RuleUpgradeData> {
+    /** Required upgrade changes for specified target version. */
+    data: any;
+    ruleEnabled: any;
+    visitNode(node: ts.Node): void;
+    visitTemplate(template: ResolvedResource): void;
+    visitStylesheet(stylesheet: ResolvedResource): void;
+    private _visitStringLiteralLike;
+    private _replaceSelector;
+}

package/typings/schematics/ng-update/upgrade-rules/class-inheritance-rule.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import * as ts from 'typescript';
+import { MigrationRule } from '../../update-tool/migration-rule';
+import { PropertyNameUpgradeData } from '../data/property-names';
+import { RuleUpgradeData } from '../upgrade-data';
+/**
+ * Rule that identifies class declarations that extend CDK or Material classes
+ * which had a public property change.
+ */
+export declare class ClassInheritanceRule extends MigrationRule<RuleUpgradeData> {
+    /**
+     * Map of classes that have been updated. Each class name maps to the according property
+     * change data.
+     */
+    propertyNames: Map<string, PropertyNameUpgradeData>;
+    ruleEnabled: boolean;
+    init(): void;
+    visitNode(node: ts.Node): void;
+    private _visitClassDeclaration;
+}

package/{schematics/ng-update/upgrade-rules/class-names/classNamesIdentifierRule.d.ts → typings/schematics/ng-update/upgrade-rules/class-names-rule.d.ts}

@@ -5,17 +5,15 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-import { RuleFailure, Rules, RuleWalker } from 'tslint';
 import * as ts from 'typescript';
-import { ClassNameUpgradeData } from '../../data';
+import { MigrationRule } from '../../update-tool/migration-rule';
+import { ClassNameUpgradeData } from '../data';
+import { RuleUpgradeData } from '../upgrade-data';
 /**
  * Rule that walks through every identifier that is part of Angular Material or thr CDK
  * and replaces the outdated name with the new one if specified in the upgrade data.
  */
-export declare class Rule extends Rules.AbstractRule {
-    apply(sourceFile: ts.SourceFile): RuleFailure[];
-}
-export declare class Walker extends RuleWalker {
+export declare class ClassNamesRule extends MigrationRule<RuleUpgradeData> {
     /** Change data that upgrades to the specified target version. */
     data: ClassNameUpgradeData[];
     /**
@@ -25,8 +23,10 @@ export declare class Walker extends RuleWalker {
     trustedIdentifiers: Set<string>;
     /** List of namespaces that have been imported from `@angular/material` or `@angular/cdk`. */
     trustedNamespaces: Set<string>;
+    ruleEnabled: boolean;
+    visitNode(node: ts.Node): void;
     /** Method that is called for every identifier inside of the specified project. */
-    visitIdentifier(identifier: ts.Identifier): void;
+    private _visitIdentifier;
     /** Creates a failure and replacement for the specified identifier. */
     private _createFailureWithReplacement;
 }

package/typings/schematics/ng-update/upgrade-rules/constructor-signature-rule.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import * as ts from 'typescript';
+import { MigrationRule } from '../../update-tool/migration-rule';
+import { RuleUpgradeData } from '../upgrade-data';
+/**
+ * Rule that visits every TypeScript new expression or super call and checks if
+ * the parameter type signature is invalid and needs to be updated manually.
+ */
+export declare class ConstructorSignatureRule extends MigrationRule<RuleUpgradeData> {
+    data: string[];
+    ruleEnabled: boolean;
+    visitNode(node: ts.Node): void;
+    /**
+     * Method that will be called for each source file of the upgrade project. In order to
+     * properly determine invalid constructor signatures, we take advantage of the pre-emit
+     * diagnostics from TypeScript.
+     *
+     * By using the diagnostics, the migration can handle type assignability. Not using
+     * diagnostics would mean that we need to use simple type equality checking which is
+     * too strict. See related issue: https://github.com/Microsoft/TypeScript/issues/9879
+     */
+    private _visitSourceFile;
+}

package/typings/schematics/ng-update/upgrade-rules/css-selectors-rule.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import * as ts from 'typescript';
+import { ResolvedResource } from '../../update-tool/component-resource-collector';
+import { MigrationRule } from '../../update-tool/migration-rule';
+import { RuleUpgradeData } from '../upgrade-data';
+/**
+ * Rule that walks through every string literal, template and stylesheet in
+ * order to migrate outdated CSS selectors to the new selector.
+ */
+export declare class CssSelectorsRule extends MigrationRule<RuleUpgradeData> {
+    /** Change data that upgrades to the specified target version. */
+    data: any;
+    ruleEnabled: any;
+    visitNode(node: ts.Node): void;
+    visitTemplate(template: ResolvedResource): void;
+    visitStylesheet(stylesheet: ResolvedResource): void;
+    private _visitStringLiteralLike;
+    private _replaceSelector;
+}

package/typings/schematics/ng-update/upgrade-rules/element-selectors-rule.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import * as ts from 'typescript';
+import { ResolvedResource } from '../../update-tool/component-resource-collector';
+import { MigrationRule } from '../../update-tool/migration-rule';
+import { RuleUpgradeData } from '../upgrade-data';
+/**
+ * Rule that walks through every string literal, template and stylesheet in order
+ * to migrate outdated element selectors to the new one.
+ */
+export declare class ElementSelectorsRule extends MigrationRule<RuleUpgradeData> {
+    /** Change data that upgrades to the specified target version. */
+    data: any;
+    ruleEnabled: any;
+    visitNode(node: ts.Node): void;
+    visitTemplate(template: ResolvedResource): void;
+    visitStylesheet(stylesheet: ResolvedResource): void;
+    private _visitStringLiteralLike;
+    private _replaceSelector;
+}

package/typings/schematics/ng-update/upgrade-rules/index.d.ts

@@ -6,7 +6,16 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { Rule } from '@angular-devkit/schematics';
-import { TargetVersion } from '../target-version';
-import { UpgradeTSLintConfig } from './tslint-config';
-/** Creates a Angular schematic rule that runs the upgrade for the specified target version. */
-export declare function createUpgradeRule(targetVersion: TargetVersion, upgradeConfig: UpgradeTSLintConfig): Rule;
+import { Constructor } from '../../update-tool';
+import { MigrationRule } from '../../update-tool/migration-rule';
+import { TargetVersion } from '../../update-tool/target-version';
+import { RuleUpgradeData } from '../upgrade-data';
+/** List of migration rules which run for the CDK update. */
+export declare const cdkMigrationRules: Constructor<MigrationRule<RuleUpgradeData>>[];
+declare type NullableMigrationRule = Constructor<MigrationRule<RuleUpgradeData | null>>;
+/**
+ * Creates a Angular schematic rule that runs the upgrade for the
+ * specified target version.
+ */
+export declare function createUpgradeRule(targetVersion: TargetVersion, extraRules: NullableMigrationRule[], upgradeData: RuleUpgradeData, onMigrationCompleteFn?: (targetVersion: TargetVersion, hasFailures: boolean) => void): Rule;
+export {};

package/typings/schematics/ng-update/upgrade-rules/input-names-rule.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { ResolvedResource } from '../../update-tool/component-resource-collector';
+import { MigrationRule } from '../../update-tool/migration-rule';
+import { InputNameUpgradeData } from '../data';
+import { RuleUpgradeData } from '../upgrade-data';
+/**
+ * Rule that walks through every template or stylesheet and replaces outdated input
+ * names to the new input name. Selectors in stylesheets could also target input
+ * bindings declared as static attribute. See for example:
+ *
+ * e.g. `<my-component color="primary">` becomes `my-component[color]`
+ */
+export declare class InputNamesRule extends MigrationRule<RuleUpgradeData> {
+    /** Change data that upgrades to the specified target version. */
+    data: InputNameUpgradeData[];
+    ruleEnabled: boolean;
+    visitStylesheet(stylesheet: ResolvedResource): void;
+    visitTemplate(template: ResolvedResource): void;
+    private _replaceInputName;
+}

package/typings/schematics/ng-update/upgrade-rules/{signature-check/methodCallsCheckRule.d.ts → method-call-arguments-rule.d.ts}

@@ -5,19 +5,18 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-import { ProgramAwareRuleWalker, RuleFailure, Rules } from 'tslint';
 import * as ts from 'typescript';
-import { MethodCallUpgradeData } from '../../data';
+import { MigrationRule } from '../../update-tool/migration-rule';
+import { MethodCallUpgradeData } from '../data';
+import { RuleUpgradeData } from '../upgrade-data';
 /**
- * Rule that visits every TypeScript method call expression and checks if the argument count
- * is invalid and needs to be *manually* updated.
+ * Rule that visits every TypeScript method call expression and checks if the
+ * argument count is invalid and needs to be *manually* updated.
  */
-export declare class Rule extends Rules.TypedRule {
-    applyWithProgram(sourceFile: ts.SourceFile, program: ts.Program): RuleFailure[];
-}
-export declare class Walker extends ProgramAwareRuleWalker {
+export declare class MethodCallArgumentsRule extends MigrationRule<RuleUpgradeData> {
     /** Change data that upgrades to the specified target version. */
     data: MethodCallUpgradeData[];
-    visitCallExpression(node: ts.CallExpression): void;
+    ruleEnabled: boolean;
+    visitNode(node: ts.Node): void;
     private _checkPropertyAccessMethodCall;
 }

package/typings/schematics/ng-update/upgrade-rules/misc-template-rule.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { ResolvedResource } from '../../update-tool/component-resource-collector';
+import { MigrationRule } from '../../update-tool/migration-rule';
+import { RuleUpgradeData } from '../upgrade-data';
+/**
+ * Rule that walks through every template and reports if there are
+ * instances of outdated Angular CDK API that can't be migrated automatically.
+ */
+export declare class MiscTemplateRule extends MigrationRule<RuleUpgradeData> {
+    ruleEnabled: boolean;
+    visitTemplate(template: ResolvedResource): void;
+}

package/typings/schematics/ng-update/upgrade-rules/output-names-rule.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { ResolvedResource } from '../../update-tool/component-resource-collector';
+import { MigrationRule } from '../../update-tool/migration-rule';
+import { OutputNameUpgradeData } from '../data';
+import { RuleUpgradeData } from '../upgrade-data';
+/**
+ * Rule that walks through every inline or external HTML template and switches
+ * changed output binding names to the proper new output name.
+ */
+export declare class OutputNamesRule extends MigrationRule<RuleUpgradeData> {
+    /** Change data that upgrades to the specified target version. */
+    data: OutputNameUpgradeData[];
+    ruleEnabled: boolean;
+    visitTemplate(template: ResolvedResource): void;
+    private _replaceOutputName;
+}

package/typings/schematics/ng-update/upgrade-rules/property-names-rule.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import * as ts from 'typescript';
+import { MigrationRule } from '../../update-tool/migration-rule';
+import { PropertyNameUpgradeData } from '../data';
+import { RuleUpgradeData } from '../upgrade-data';
+/**
+ * Rule that walks through every property access expression and updates
+ * accessed properties that have been updated to a new name.
+ */
+export declare class PropertyNamesRule extends MigrationRule<RuleUpgradeData> {
+    /** Change data that upgrades to the specified target version. */
+    data: PropertyNameUpgradeData[];
+    ruleEnabled: boolean;
+    visitNode(node: ts.Node): void;
+    private _visitPropertyAccessExpression;
+}

package/typings/schematics/update-tool/component-resource-collector.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import * as ts from 'typescript';
+import { LineAndCharacter } from './utils/line-mappings';
+export interface ResolvedResource {
+    /** Class declaration that contains this resource. */
+    container: ts.ClassDeclaration | null;
+    /** File content of the given template. */
+    content: string;
+    /** Start offset of the resource content (e.g. in the inline source file) */
+    start: number;
+    /** Whether the given resource is inline or not. */
+    inline: boolean;
+    /** Path to the file that contains this resource. */
+    filePath: string;
+    /**
+     * Gets the character and line of a given position index in the resource.
+     * If the resource is declared inline within a TypeScript source file, the line and
+     * character are based on the full source file content.
+     */
+    getCharacterAndLineOfPosition: (pos: number) => LineAndCharacter;
+}
+/**
+ * Collector that can be used to find Angular templates and stylesheets referenced within
+ * given TypeScript source files (inline or external referenced files)
+ */
+export declare class ComponentResourceCollector {
+    typeChecker: ts.TypeChecker;
+    resolvedTemplates: ResolvedResource[];
+    resolvedStylesheets: ResolvedResource[];
+    constructor(typeChecker: ts.TypeChecker);
+    visitNode(node: ts.Node): void;
+    private _visitClassDeclaration;
+    /** Resolves an external stylesheet by reading its content and computing line mappings. */
+    resolveExternalStylesheet(filePath: string, container: ts.ClassDeclaration | null): ResolvedResource;
+}

package/typings/schematics/update-tool/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { logging } from '@angular-devkit/core';
+import { Tree } from '@angular-devkit/schematics';
+import { MigrationRule } from './migration-rule';
+import { TargetVersion } from './target-version';
+export declare type Constructor<T> = new (...args: any[]) => T;
+export declare function runMigrationRules<T>(tree: Tree, logger: logging.LoggerApi, tsconfigPath: string, targetVersion: TargetVersion, ruleTypes: Constructor<MigrationRule<T>>[], upgradeData: T, analyzedFiles: Set<string>): boolean;

package/typings/schematics/update-tool/migration-rule.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { UpdateRecorder } from '@angular-devkit/schematics';
+import * as ts from 'typescript';
+import { ResolvedResource } from './component-resource-collector';
+import { TargetVersion } from './target-version';
+import { LineAndCharacter } from './utils/line-mappings';
+export interface MigrationFailure {
+    filePath: string;
+    message: string;
+    position: LineAndCharacter;
+}
+export declare class MigrationRule<T> {
+    program: ts.Program;
+    typeChecker: ts.TypeChecker;
+    targetVersion: TargetVersion;
+    upgradeData: T;
+    /** List of migration failures that need to be reported. */
+    failures: MigrationFailure[];
+    /** Whether the migration rule is enabled or not. */
+    ruleEnabled: boolean;
+    constructor(program: ts.Program, typeChecker: ts.TypeChecker, targetVersion: TargetVersion, upgradeData: T);
+    /** Method can be used to perform global analysis of the program. */
+    init(): void;
+    /**
+     * Method that will be called for each node in a given source file. Unlike tslint, this
+     * function will only retrieve TypeScript nodes that need to be casted manually. This
+     * allows us to only walk the program source files once per program and not per
+     * migration rule (significant performance boost).
+     */
+    visitNode(node: ts.Node): void;
+    /** Method that will be called for each Angular template in the program. */
+    visitTemplate(template: ResolvedResource): void;
+    /** Method that will be called for each stylesheet in the program. */
+    visitStylesheet(stylesheet: ResolvedResource): void;
+    /** Gets the update recorder for a given source file or resolved template. */
+    getUpdateRecorder(filePath: string): UpdateRecorder;
+    /** Creates a failure with a specified message at the given node location. */
+    createFailureAtNode(node: ts.Node, message: string): void;
+}

package/typings/schematics/update-tool/public-api.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export * from './index';
+export * from './target-version';
+export * from './version-changes';
+export * from './migration-rule';
+export * from './component-resource-collector';

package/typings/schematics/{ng-update → update-tool}/target-version.d.ts

@@ -7,9 +7,9 @@
  */
 /** Possible versions that can be automatically migrated by `ng update`. */
 export declare enum TargetVersion {
-    V6 = 0,
-    V7 = 1,
-    V8 = 2
+    V6 = "version 6",
+    V7 = "version 7",
+    V8 = "version 8"
 }
 /**
  * Returns all versions that are supported by "ng update". The versions are determined

package/typings/schematics/update-tool/utils/decorators.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import * as ts from 'typescript';
+import { Import } from './imports';
+export declare type CallExpressionDecorator = ts.Decorator & {
+    expression: ts.CallExpression;
+};
+export interface NgDecorator {
+    name: string;
+    node: CallExpressionDecorator;
+    importNode: ts.ImportDeclaration;
+}
+/**
+ * Gets all decorators which are imported from an Angular package
+ * (e.g. "@angular/core") from a list of decorators.
+ */
+export declare function getAngularDecorators(typeChecker: ts.TypeChecker, decorators: ReadonlyArray<ts.Decorator>): NgDecorator[];
+export declare function getCallDecoratorImport(typeChecker: ts.TypeChecker, decorator: ts.Decorator): Import | null;

package/typings/schematics/update-tool/utils/functions.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import * as ts from 'typescript';
+/**
+ * Unwraps a given expression TypeScript node. Expressions can be wrapped within multiple
+ * parentheses. e.g. "(((({exp}))))()". The function should return the TypeScript node
+ * referring to the inner expression. e.g "exp".
+ */
+export declare function unwrapExpression(node: ts.Expression | ts.ParenthesizedExpression): ts.Expression;

package/typings/schematics/update-tool/utils/imports.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import * as ts from 'typescript';
+export declare type Import = {
+    name: string;
+    importModule: string;
+    node: ts.ImportDeclaration;
+};
+/** Gets import information about the specified identifier by using the type checker. */
+export declare function getImportOfIdentifier(typeChecker: ts.TypeChecker, node: ts.Identifier): Import | null;

package/typings/schematics/update-tool/utils/line-mappings.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export interface LineAndCharacter {
+    character: number;
+    line: number;
+}
+/** Gets the line and character for the given position from the line starts map. */
+export declare function getLineAndCharacterFromPosition(lineStartsMap: number[], position: number): {
+    character: number;
+    line: number;
+};
+/**
+ * Computes the line start map of the given text. This can be used in order to
+ * retrieve the line and character of a given text position index.
+ */
+export declare function computeLineStartsMap(text: string): number[];

package/typings/schematics/update-tool/utils/parse-tsconfig.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import * as ts from 'typescript';
+export declare function parseTsconfigFile(tsconfigPath: string, basePath: string): ts.ParsedCommandLine;

package/typings/schematics/update-tool/utils/property-name.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import * as ts from 'typescript';
+/** Type that describes a property name with an obtainable text. */
+declare type PropertyNameWithText = Exclude<ts.PropertyName, ts.ComputedPropertyName>;
+/**
+ * Gets the text of the given property name. Returns null if the property
+ * name couldn't be determined statically.
+ */
+export declare function getPropertyNameText(node: ts.PropertyName): string | null;
+/** Checks whether the given property name has a text. */
+export declare function hasPropertyNameText(node: ts.PropertyName): node is PropertyNameWithText;
+export {};