@angular/compiler-cli 15.2.0-rc.0 → 16.0.0-next.0

package/ngcc/src/execution/tasks/api.d.ts

@@ -1,141 +0,0 @@
-/**
- * @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 { EntryPoint, EntryPointJsonProperty } from '../../packages/entry_point';
-import { JsonObject, PartiallyOrderedList } from '../../utils';
-/**
- * Represents a unit of work to be undertaken by an `Executor`.
- *
- * A task consists of processing a specific format property of an entry-point.
- * This may or may not also include processing the typings for that entry-point, which only needs to
- * happen once across all the formats.
- */
-export interface Task extends JsonObject {
-    /** The `EntryPoint` which needs to be processed as part of the task. */
-    entryPoint: EntryPoint;
-    /**
-     * The `package.json` format property to process (i.e. the property which points to the file that
-     * is the program entry-point).
-     */
-    formatProperty: EntryPointJsonProperty;
-    /**
-     * The list of all format properties (including `task.formatProperty`) that should be marked as
-     * processed once the task has been completed, because they point to the format-path that will be
-     * processed as part of the task.
-     */
-    formatPropertiesToMarkAsProcessed: EntryPointJsonProperty[];
-    /**
-     * Whether to process typings for this entry-point as part of the task.
-     */
-    processDts: DtsProcessing;
-}
-/**
- * The options for processing Typescript typings (.d.ts) files.
- */
-export declare enum DtsProcessing {
-    /**
-     * Yes, process the typings for this entry point as part of the task.
-     */
-    Yes = 0,
-    /**
-     * No, do not process the typings as part of this task - they must have already been processed by
-     * another task or previous ngcc process.
-     */
-    No = 1,
-    /**
-     * Only process the typings for this entry-point; do not render any JavaScript files for the
-     * `formatProperty` of this task.
-     */
-    Only = 2
-}
-/**
- * Represents a partially ordered list of tasks.
- *
- * The ordering/precedence of tasks is determined by the inter-dependencies between their associated
- * entry-points. Specifically, the tasks' order/precedence is such that tasks associated to
- * dependent entry-points always come after tasks associated with their dependencies.
- *
- * As result of this ordering, it is guaranteed that - by processing tasks in the order in which
- * they appear in the list - a task's dependencies will always have been processed before processing
- * the task itself.
- *
- * See `DependencyResolver#sortEntryPointsByDependency()`.
- */
-export type PartiallyOrderedTasks = PartiallyOrderedList<Task>;
-/**
- * A mapping from Tasks to the Tasks that depend upon them (dependents).
- */
-export type TaskDependencies = Map<Task, Set<Task>>;
-export declare const TaskDependencies: MapConstructor;
-/**
- * A function to create a TaskCompletedCallback function.
- */
-export type CreateTaskCompletedCallback = (taskQueue: TaskQueue) => TaskCompletedCallback;
-/**
- * A function to be called once a task has been processed.
- */
-export type TaskCompletedCallback = (task: Task, outcome: TaskProcessingOutcome, message: string | null) => void;
-/**
- * Represents the outcome of processing a `Task`.
- */
-export declare const enum TaskProcessingOutcome {
-    /** Successfully processed the target format property. */
-    Processed = 0,
-    /** Failed to process the target format. */
-    Failed = 1
-}
-/**
- * A wrapper around a list of tasks and providing utility methods for getting the next task of
- * interest and determining when all tasks have been completed.
- *
- * (This allows different implementations to impose different constraints on when a task's
- * processing can start.)
- */
-export interface TaskQueue {
-    /** Whether all tasks have been completed. */
-    allTasksCompleted: boolean;
-    /**
-     * Get the next task whose processing can start (if any).
-     *
-     * This implicitly marks the task as in-progress.
-     * (This information is used to determine whether all tasks have been completed.)
-     *
-     * @return The next task available for processing or `null`, if no task can be processed at the
-     *         moment (including if there are no more unprocessed tasks).
-     */
-    getNextTask(): Task | null;
-    /**
-     * Mark a task as completed.
-     *
-     * This removes the task from the internal list of in-progress tasks.
-     * (This information is used to determine whether all tasks have been completed.)
-     *
-     * @param task The task to mark as completed.
-     */
-    markAsCompleted(task: Task): void;
-    /**
-     * Mark a task as failed.
-     *
-     * Do not process the tasks that depend upon the given task.
-     */
-    markAsFailed(task: Task): void;
-    /**
-     * Mark a task as not processed (i.e. add an in-progress task back to the queue).
-     *
-     * This removes the task from the internal list of in-progress tasks and adds it back to the list
-     * of pending tasks.
-     *
-     * @param task The task to mark as not processed.
-     */
-    markAsUnprocessed(task: Task): void;
-    /**
-     * Return a string representation of the task queue (for debugging purposes).
-     *
-     * @return A string representation of the task queue.
-     */
-    toString(): string;
-}

package/ngcc/src/execution/tasks/completion.d.ts

@@ -1,41 +0,0 @@
-/**
- * @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 { PathManipulation, ReadonlyFileSystem } from '../../../../src/ngtsc/file_system';
-import { Logger } from '../../../../src/ngtsc/logging';
-import { PackageJsonUpdater } from '../../writing/package_json_updater';
-import { Task, TaskCompletedCallback, TaskProcessingOutcome, TaskQueue } from './api';
-/**
- * A function that can handle a specific outcome of a task completion.
- *
- * These functions can be composed using the `composeTaskCompletedCallbacks()`
- * to create a `TaskCompletedCallback` function that can be passed to an `Executor`.
- */
-export type TaskCompletedHandler = (task: Task, message: string | null) => void;
-/**
- * Compose a group of TaskCompletedHandlers into a single TaskCompletedCallback.
- *
- * The compose callback will receive an outcome and will delegate to the appropriate handler based
- * on this outcome.
- *
- * @param callbacks a map of outcomes to handlers.
- */
-export declare function composeTaskCompletedCallbacks(callbacks: Record<TaskProcessingOutcome, TaskCompletedHandler>): TaskCompletedCallback;
-/**
- * Create a handler that will mark the entry-points in a package as being processed.
- *
- * @param pkgJsonUpdater The service used to update the package.json
- */
-export declare function createMarkAsProcessedHandler(fs: PathManipulation, pkgJsonUpdater: PackageJsonUpdater): TaskCompletedHandler;
-/**
- * Create a handler that will throw an error.
- */
-export declare function createThrowErrorHandler(fs: ReadonlyFileSystem): TaskCompletedHandler;
-/**
- * Create a handler that logs an error and marks the task as failed.
- */
-export declare function createLogErrorHandler(logger: Logger, fs: ReadonlyFileSystem, taskQueue: TaskQueue): TaskCompletedHandler;

package/ngcc/src/execution/tasks/queues/base_task_queue.d.ts

@@ -1,38 +0,0 @@
-/**
- * @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 { Logger } from '../../../../../src/ngtsc/logging';
-import { PartiallyOrderedTasks, Task, TaskDependencies, TaskQueue } from '../api';
-/**
- * A base `TaskQueue` implementation to be used as base for concrete implementations.
- */
-export declare abstract class BaseTaskQueue implements TaskQueue {
-    protected logger: Logger;
-    protected tasks: PartiallyOrderedTasks;
-    protected dependencies: TaskDependencies;
-    get allTasksCompleted(): boolean;
-    protected inProgressTasks: Set<Task>;
-    /**
-     * A map of tasks that should be skipped, mapped to the task that caused them to be skipped.
-     */
-    private tasksToSkip;
-    constructor(logger: Logger, tasks: PartiallyOrderedTasks, dependencies: TaskDependencies);
-    protected abstract computeNextTask(): Task | null;
-    getNextTask(): Task | null;
-    markAsCompleted(task: Task): void;
-    markAsFailed(task: Task): void;
-    markAsUnprocessed(task: Task): void;
-    toString(): string;
-    /**
-     * Mark the given `task` as to be skipped, then recursive skip all its dependents.
-     *
-     * @param task The task to skip
-     * @param failedTask The task that failed, causing this task to be skipped
-     */
-    protected skipDependentTasks(task: Task, failedTask: Task): void;
-    protected stringifyTasks(tasks: Task[], indentation: string): string;
-}

package/ngcc/src/execution/tasks/queues/parallel_task_queue.d.ts

@@ -1,27 +0,0 @@
-/**
- * @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 { Logger } from '../../../../../src/ngtsc/logging';
-import { PartiallyOrderedTasks, Task, TaskDependencies } from '../api';
-import { BaseTaskQueue } from './base_task_queue';
-/**
- * A `TaskQueue` implementation that assumes tasks are processed in parallel, thus has to ensure a
- * task's dependencies have been processed before processing the task.
- */
-export declare class ParallelTaskQueue extends BaseTaskQueue {
-    /**
-     * A map from Tasks to the Tasks that it depends upon.
-     *
-     * This is the reverse mapping of `TaskDependencies`.
-     */
-    private blockedTasks;
-    constructor(logger: Logger, tasks: PartiallyOrderedTasks, dependencies: TaskDependencies);
-    computeNextTask(): Task | null;
-    markAsCompleted(task: Task): void;
-    toString(): string;
-    private stringifyBlockedTasks;
-}

package/ngcc/src/execution/tasks/queues/serial_task_queue.d.ts

@@ -1,16 +0,0 @@
-/**
- * @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 { Task } from '../api';
-import { BaseTaskQueue } from './base_task_queue';
-/**
- * A `TaskQueue` implementation that assumes tasks are processed serially and each one is completed
- * before requesting the next one.
- */
-export declare class SerialTaskQueue extends BaseTaskQueue {
-    computeNextTask(): Task | null;
-}

package/ngcc/src/execution/tasks/utils.d.ts

@@ -1,57 +0,0 @@
-/**
- * @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 { DepGraph } from 'dependency-graph';
-import { EntryPoint } from '../../packages/entry_point';
-import { PartiallyOrderedTasks, Task, TaskDependencies } from './api';
-/** Stringify a task for debugging purposes. */
-export declare const stringifyTask: (task: Task) => string;
-/**
- * Compute a mapping of tasks to the tasks that are dependent on them (if any).
- *
- * Task A can depend upon task B, if either:
- *
- * * A and B have the same entry-point _and_ B is generating the typings for that entry-point
- *   (i.e. has `processDts: true`).
- * * A's entry-point depends on B's entry-point _and_ B is also generating typings.
- *
- * NOTE: If a task is not generating typings, then it cannot affect anything which depends on its
- *       entry-point, regardless of the dependency graph. To put this another way, only the task
- *       which produces the typings for a dependency needs to have been completed.
- *
- * As a performance optimization, we take into account the fact that `tasks` are sorted in such a
- * way that a task can only depend on earlier tasks (i.e. dependencies always come before
- * dependents in the list of tasks).
- *
- * @param tasks A (partially ordered) list of tasks.
- * @param graph The dependency graph between entry-points.
- * @return A map from each task to those tasks directly dependent upon it.
- */
-export declare function computeTaskDependencies(tasks: PartiallyOrderedTasks, graph: DepGraph<EntryPoint>): TaskDependencies;
-export declare function getDependentsSet(map: TaskDependencies, task: Task): Set<Task>;
-/**
- * Invert the given mapping of Task dependencies.
- *
- * @param dependencies The mapping of tasks to the tasks that depend upon them.
- * @returns A mapping of tasks to the tasks that they depend upon.
- */
-export declare function getBlockedTasks(dependencies: TaskDependencies): Map<Task, Set<Task>>;
-/**
- * Sort a list of tasks by priority.
- *
- * Priority is determined by the number of other tasks that a task is (transitively) blocking:
- * The more tasks a task is blocking the higher its priority is, because processing it will
- * potentially unblock more tasks.
- *
- * To keep the behavior predictable, if two tasks block the same number of other tasks, their
- * relative order in the original `tasks` lists is preserved.
- *
- * @param tasks A (partially ordered) list of tasks.
- * @param dependencies The mapping of tasks to the tasks that depend upon them.
- * @return The list of tasks sorted by priority.
- */
-export declare function sortTasksByPriority(tasks: PartiallyOrderedTasks, dependencies: TaskDependencies): PartiallyOrderedTasks;

package/ngcc/src/host/commonjs_host.d.ts

@@ -1,69 +0,0 @@
-/**
- * @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 ts from 'typescript';
-import { Logger } from '../../../src/ngtsc/logging';
-import { Declaration, Import } from '../../../src/ngtsc/reflection';
-import { BundleProgram } from '../packages/bundle_program';
-import { FactoryMap } from '../utils';
-import { Esm5ReflectionHost } from './esm5_host';
-import { NgccClassSymbol } from './ngcc_host';
-export declare class CommonJsReflectionHost extends Esm5ReflectionHost {
-    protected commonJsExports: FactoryMap<ts.SourceFile, Map<string, Declaration<ts.Declaration>> | null>;
-    protected topLevelHelperCalls: FactoryMap<string, FactoryMap<ts.SourceFile, ts.CallExpression[]>>;
-    protected program: ts.Program;
-    protected compilerHost: ts.CompilerHost;
-    constructor(logger: Logger, isCore: boolean, src: BundleProgram, dts?: BundleProgram | null);
-    getImportOfIdentifier(id: ts.Identifier): Import | null;
-    getDeclarationOfIdentifier(id: ts.Identifier): Declaration | null;
-    getExportsOfModule(module: ts.Node): Map<string, Declaration> | null;
-    /**
-     * Search statements related to the given class for calls to the specified helper.
-     *
-     * In CommonJS these helper calls can be outside the class's IIFE at the top level of the
-     * source file. Searching the top level statements for helpers can be expensive, so we
-     * try to get helpers from the IIFE first and only fall back on searching the top level if
-     * no helpers are found.
-     *
-     * @param classSymbol the class whose helper calls we are interested in.
-     * @param helperNames the names of the helpers (e.g. `__decorate`) whose calls we are interested
-     * in.
-     * @returns an array of nodes of calls to the helper with the given name.
-     */
-    protected getHelperCallsForClass(classSymbol: NgccClassSymbol, helperNames: string[]): ts.CallExpression[];
-    /**
-     * Find all the helper calls at the top level of a source file.
-     *
-     * We cache the helper calls per source file so that we don't have to keep parsing the code for
-     * each class in a file.
-     *
-     * @param sourceFile the source who may contain helper calls.
-     * @param helperNames the names of the helpers (e.g. `__decorate`) whose calls we are interested
-     * in.
-     * @returns an array of nodes of calls to the helper with the given name.
-     */
-    private getTopLevelHelperCalls;
-    private computeExportsOfCommonJsModule;
-    private extractBasicCommonJsExportDeclaration;
-    private extractCommonJsWildcardReexports;
-    private extractCommonJsDefinePropertyExportDeclaration;
-    private findCommonJsImport;
-    /**
-     * Handle the case where the identifier represents a reference to a whole CommonJS
-     * module, i.e. the result of a call to `require(...)`.
-     *
-     * @param id the identifier whose declaration we are looking for.
-     * @returns a declaration if `id` refers to a CommonJS module, or `null` otherwise.
-     */
-    private getCommonJsModuleDeclaration;
-    /**
-     * If this is an IFE then try to grab the outer and inner classes otherwise fallback on the super
-     * class.
-     */
-    protected getDeclarationOfExpression(expression: ts.Expression): Declaration | null;
-    private resolveModuleName;
-}

package/ngcc/src/host/commonjs_umd_utils.d.ts

@@ -1,146 +0,0 @@
-/**
- * @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 ts from 'typescript';
-import { Declaration } from '../../../src/ngtsc/reflection';
-export interface ExportDeclaration {
-    name: string;
-    declaration: Declaration;
-}
-/**
- * A CommonJS or UMD wildcard re-export statement.
- *
- * The CommonJS or UMD version of `export * from 'blah';`.
- *
- * These statements can have several forms (depending, for example, on whether
- * the TypeScript helpers are imported or emitted inline). The expression can have one of the
- * following forms:
- * - `__export(firstArg)`
- * - `__exportStar(firstArg)`
- * - `tslib.__export(firstArg, exports)`
- * - `tslib.__exportStar(firstArg, exports)`
- *
- * In all cases, we only care about `firstArg`, which is the first argument of the re-export call
- * expression and can be either a `require('...')` call or an identifier (initialized via a
- * `require('...')` call).
- */
-export interface WildcardReexportStatement extends ts.ExpressionStatement {
-    expression: ts.CallExpression;
-}
-/**
- * A CommonJS or UMD re-export statement using an `Object.defineProperty()` call.
- * For example:
- *
- * ```
- * Object.defineProperty(exports, "<exported-id>",
- *     { enumerable: true, get: function () { return <imported-id>; } });
- * ```
- */
-export interface DefinePropertyReexportStatement extends ts.ExpressionStatement {
-    expression: ts.CallExpression & {
-        arguments: [ts.Identifier, ts.StringLiteral, ts.ObjectLiteralExpression];
-    };
-}
-/**
- * A call expression that has a string literal for its first argument.
- */
-export interface RequireCall extends ts.CallExpression {
-    arguments: ts.CallExpression['arguments'] & [ts.StringLiteral];
-}
-/**
- * Return the "namespace" of the specified `ts.Identifier` if the identifier is the RHS of a
- * property access expression, i.e. an expression of the form `<namespace>.<id>` (in which case a
- * `ts.Identifier` corresponding to `<namespace>` will be returned). Otherwise return `null`.
- */
-export declare function findNamespaceOfIdentifier(id: ts.Identifier): ts.Identifier | null;
-/**
- * Return the `RequireCall` that is used to initialize the specified `ts.Identifier`, if the
- * specified identifier was indeed initialized with a require call in a declaration of the form:
- * `var <id> = require('...')`
- */
-export declare function findRequireCallReference(id: ts.Identifier, checker: ts.TypeChecker): RequireCall | null;
-/**
- * Check whether the specified `ts.Statement` is a wildcard re-export statement.
- * I.E. an expression statement of one of the following forms:
- * - `__export(<foo>)`
- * - `__exportStar(<foo>)`
- * - `tslib.__export(<foo>, exports)`
- * - `tslib.__exportStar(<foo>, exports)`
- */
-export declare function isWildcardReexportStatement(stmt: ts.Statement): stmt is WildcardReexportStatement;
-/**
- * Check whether the statement is a re-export of the form:
- *
- * ```
- * Object.defineProperty(exports, "<export-name>",
- *     { enumerable: true, get: function () { return <import-name>; } });
- * ```
- */
-export declare function isDefinePropertyReexportStatement(stmt: ts.Statement): stmt is DefinePropertyReexportStatement;
-/**
- * Extract the "value" of the getter in a `defineProperty` statement.
- *
- * This will return the `ts.Expression` value of a single `return` statement in the `get` method
- * of the property definition object, or `null` if that is not possible.
- */
-export declare function extractGetterFnExpression(statement: DefinePropertyReexportStatement): ts.Expression | null;
-/**
- * Check whether the specified `ts.Node` represents a `require()` call, i.e. an call expression of
- * the form: `require('<foo>')`
- */
-export declare function isRequireCall(node: ts.Node): node is RequireCall;
-/**
- * Check whether the specified `path` is an "external" import.
- * In other words, that it comes from a entry-point outside the current one.
- */
-export declare function isExternalImport(path: string): boolean;
-/**
- * A UMD/CommonJS style export declaration of the form `exports.<name>`.
- */
-export interface ExportsDeclaration extends ts.PropertyAccessExpression {
-    name: ts.Identifier;
-    expression: ts.Identifier;
-    parent: ExportsAssignment;
-}
-/**
- * Check whether the specified `node` is a property access expression of the form
- * `exports.<foo>`.
- */
-export declare function isExportsDeclaration(expr: ts.Node): expr is ExportsDeclaration;
-/**
- * A UMD/CommonJS style export assignment of the form `exports.<foo> = <bar>`.
- */
-export interface ExportsAssignment extends ts.BinaryExpression {
-    left: ExportsDeclaration;
-}
-/**
- * Check whether the specified `node` is an assignment expression of the form
- * `exports.<foo> = <bar>`.
- */
-export declare function isExportsAssignment(expr: ts.Node): expr is ExportsAssignment;
-/**
- * An expression statement of the form `exports.<foo> = <bar>;`.
- */
-export interface ExportsStatement extends ts.ExpressionStatement {
-    expression: ExportsAssignment;
-}
-/**
- * Check whether the specified `stmt` is an expression statement of the form
- * `exports.<foo> = <bar>;`.
- */
-export declare function isExportsStatement(stmt: ts.Node): stmt is ExportsStatement;
-/**
- * Find the far right hand side of a sequence of aliased assignments of the form
- *
- * ```
- * exports.MyClass = alias1 = alias2 = <<declaration>>
- * ```
- *
- * @param node the expression to parse
- * @returns the original `node` or the far right expression of a series of assignments.
- */
-export declare function skipAliases(node: ts.Expression): ts.Expression;

package/ngcc/src/host/delegating_host.d.ts

@@ -1,43 +0,0 @@
-/**
- * @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 ts from 'typescript';
-import { ClassDeclaration, ClassMember, CtorParameter, Declaration, DeclarationNode, Decorator, FunctionDefinition, Import, ReflectionHost } from '../../../src/ngtsc/reflection';
-import { NgccClassSymbol, NgccReflectionHost } from './ngcc_host';
-/**
- * A reflection host implementation that delegates reflector queries depending on whether they
- * reflect on declaration files (for dependent libraries) or source files within the entry-point
- * that is being compiled. The first type of queries are handled by the regular TypeScript
- * reflection host, whereas the other queries are handled by an `NgccReflectionHost` that is
- * specific to the entry-point's format.
- */
-export declare class DelegatingReflectionHost implements NgccReflectionHost {
-    private tsHost;
-    private ngccHost;
-    constructor(tsHost: ReflectionHost, ngccHost: NgccReflectionHost);
-    getConstructorParameters(clazz: ClassDeclaration): CtorParameter[] | null;
-    getDeclarationOfIdentifier(id: ts.Identifier): Declaration | null;
-    getDecoratorsOfDeclaration(declaration: DeclarationNode): Decorator[] | null;
-    getDefinitionOfFunction(fn: ts.Node): FunctionDefinition | null;
-    getDtsDeclaration(declaration: DeclarationNode): ts.Declaration | null;
-    getExportsOfModule(module: ts.Node): Map<string, Declaration> | null;
-    getGenericArityOfClass(clazz: ClassDeclaration): number | null;
-    getImportOfIdentifier(id: ts.Identifier): Import | null;
-    getInternalNameOfClass(clazz: ClassDeclaration): ts.Identifier;
-    getAdjacentNameOfClass(clazz: ClassDeclaration): ts.Identifier;
-    getMembersOfClass(clazz: ClassDeclaration): ClassMember[];
-    getVariableValue(declaration: ts.VariableDeclaration): ts.Expression | null;
-    hasBaseClass(clazz: ClassDeclaration): boolean;
-    getBaseClassExpression(clazz: ClassDeclaration): ts.Expression | null;
-    isClass(node: ts.Node): node is ClassDeclaration;
-    findClassSymbols(sourceFile: ts.SourceFile): NgccClassSymbol[];
-    getClassSymbol(node: ts.Node): NgccClassSymbol | undefined;
-    getDecoratorsOfSymbol(symbol: NgccClassSymbol): Decorator[] | null;
-    getEndOfClass(classSymbol: NgccClassSymbol): ts.Node;
-    detectKnownDeclaration<T extends Declaration>(decl: T): T;
-    isStaticallyExported(decl: ts.Node): boolean;
-}