static-injector 2.0.0 → 2.1.1

package/transform/compiler-cli/src/ngtsc/translator/src/translator.d.ts

@@ -5,11 +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 * as o from '../../../../../compiler';
+import * as o from 'static-injector/transform/compiler';
 import { AstFactory } from './api/ast_factory';
 import { ImportGenerator } from './api/import_generator';
 import { Context } from './context';
-export declare type RecordWrappedNodeFn<TExpression> = (node: o.WrappedNodeExpr<TExpression>) => void;
+export type RecordWrappedNodeFn<TExpression> = (node: o.WrappedNodeExpr<TExpression>) => void;
 export interface TranslatorOptions<TExpression> {
     downlevelTaggedTemplates?: boolean;
     downlevelVariableDeclarations?: boolean;

package/transform/compiler-cli/src/ngtsc/translator/src/translator.js

@@ -31,7 +31,7 @@ exports.ExpressionTranslatorVisitor = void 0;
  * 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
  */
-const o = __importStar(require("../../../../../compiler"));
+const o = __importStar(require("static-injector/transform/compiler"));
 const UNARY_OPERATORS = new Map([
     [o.UnaryOperator.Minus, '-'],
     [o.UnaryOperator.Plus, '+'],

package/transform/compiler-cli/src/ngtsc/translator/src/typescript_ast_factory.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 * as ts from 'typescript';
+import ts from 'typescript';
 import { AstFactory, BinaryOperator, LeadingComment, ObjectLiteralProperty, SourceMapRange, TemplateLiteral, UnaryOperator, VariableDeclarationType } from './api/ast_factory';
 /**
  * A TypeScript flavoured implementation of the AstFactory.

package/transform/compiler-cli/src/ngtsc/translator/src/typescript_ast_factory.js

@@ -1,26 +1,6 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.attachComments = exports.createTemplateTail = exports.createTemplateMiddle = exports.TypeScriptAstFactory = void 0;
@@ -31,7 +11,8 @@ exports.attachComments = exports.createTemplateTail = exports.createTemplateMidd
  * 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
  */
-const ts = __importStar(require("typescript"));
+const typescript_1 = __importDefault(require("typescript"));
+const ts_compatibility_1 = require("../../ts_compatibility");
 /**
  * Different optimizers use different annotations on a function or method call to indicate its pure
  * status.
@@ -47,33 +28,33 @@ var PureAnnotation;
     PureAnnotation["TERSER"] = "@__PURE__";
 })(PureAnnotation || (PureAnnotation = {}));
 const UNARY_OPERATORS = {
-    '+': ts.SyntaxKind.PlusToken,
-    '-': ts.SyntaxKind.MinusToken,
-    '!': ts.SyntaxKind.ExclamationToken,
+    '+': typescript_1.default.SyntaxKind.PlusToken,
+    '-': typescript_1.default.SyntaxKind.MinusToken,
+    '!': typescript_1.default.SyntaxKind.ExclamationToken,
 };
 const BINARY_OPERATORS = {
-    '&&': ts.SyntaxKind.AmpersandAmpersandToken,
-    '>': ts.SyntaxKind.GreaterThanToken,
-    '>=': ts.SyntaxKind.GreaterThanEqualsToken,
-    '&': ts.SyntaxKind.AmpersandToken,
-    '/': ts.SyntaxKind.SlashToken,
-    '==': ts.SyntaxKind.EqualsEqualsToken,
-    '===': ts.SyntaxKind.EqualsEqualsEqualsToken,
-    '<': ts.SyntaxKind.LessThanToken,
-    '<=': ts.SyntaxKind.LessThanEqualsToken,
-    '-': ts.SyntaxKind.MinusToken,
-    '%': ts.SyntaxKind.PercentToken,
-    '*': ts.SyntaxKind.AsteriskToken,
-    '!=': ts.SyntaxKind.ExclamationEqualsToken,
-    '!==': ts.SyntaxKind.ExclamationEqualsEqualsToken,
-    '||': ts.SyntaxKind.BarBarToken,
-    '+': ts.SyntaxKind.PlusToken,
-    '??': ts.SyntaxKind.QuestionQuestionToken,
+    '&&': typescript_1.default.SyntaxKind.AmpersandAmpersandToken,
+    '>': typescript_1.default.SyntaxKind.GreaterThanToken,
+    '>=': typescript_1.default.SyntaxKind.GreaterThanEqualsToken,
+    '&': typescript_1.default.SyntaxKind.AmpersandToken,
+    '/': typescript_1.default.SyntaxKind.SlashToken,
+    '==': typescript_1.default.SyntaxKind.EqualsEqualsToken,
+    '===': typescript_1.default.SyntaxKind.EqualsEqualsEqualsToken,
+    '<': typescript_1.default.SyntaxKind.LessThanToken,
+    '<=': typescript_1.default.SyntaxKind.LessThanEqualsToken,
+    '-': typescript_1.default.SyntaxKind.MinusToken,
+    '%': typescript_1.default.SyntaxKind.PercentToken,
+    '*': typescript_1.default.SyntaxKind.AsteriskToken,
+    '!=': typescript_1.default.SyntaxKind.ExclamationEqualsToken,
+    '!==': typescript_1.default.SyntaxKind.ExclamationEqualsEqualsToken,
+    '||': typescript_1.default.SyntaxKind.BarBarToken,
+    '+': typescript_1.default.SyntaxKind.PlusToken,
+    '??': typescript_1.default.SyntaxKind.QuestionQuestionToken,
 };
 const VAR_TYPES = {
-    const: ts.NodeFlags.Const,
-    let: ts.NodeFlags.Let,
-    var: ts.NodeFlags.None,
+    const: typescript_1.default.NodeFlags.Const,
+    let: typescript_1.default.NodeFlags.Let,
+    var: typescript_1.default.NodeFlags.None,
 };
 /**
  * A TypeScript flavoured implementation of the AstFactory.
@@ -83,28 +64,28 @@ class TypeScriptAstFactory {
         this.annotateForClosureCompiler = annotateForClosureCompiler;
         this.externalSourceFiles = new Map();
         this.attachComments = attachComments;
-        this.createArrayLiteral = ts.factory.createArrayLiteralExpression;
-        this.createElementAccess = ts.factory.createElementAccessExpression;
-        this.createExpressionStatement = ts.factory.createExpressionStatement;
-        this.createIdentifier = ts.factory.createIdentifier;
-        this.createParenthesizedExpression = ts.factory.createParenthesizedExpression;
-        this.createPropertyAccess = ts.factory.createPropertyAccessExpression;
-        this.createThrowStatement = ts.factory.createThrowStatement;
-        this.createTypeOfExpression = ts.factory.createTypeOfExpression;
+        this.createArrayLiteral = typescript_1.default.factory.createArrayLiteralExpression;
+        this.createElementAccess = typescript_1.default.factory.createElementAccessExpression;
+        this.createExpressionStatement = typescript_1.default.factory.createExpressionStatement;
+        this.createIdentifier = typescript_1.default.factory.createIdentifier;
+        this.createParenthesizedExpression = typescript_1.default.factory.createParenthesizedExpression;
+        this.createPropertyAccess = typescript_1.default.factory.createPropertyAccessExpression;
+        this.createThrowStatement = typescript_1.default.factory.createThrowStatement;
+        this.createTypeOfExpression = typescript_1.default.factory.createTypeOfExpression;
     }
     createAssignment(target, value) {
-        return ts.factory.createBinaryExpression(target, ts.SyntaxKind.EqualsToken, value);
+        return typescript_1.default.factory.createBinaryExpression(target, typescript_1.default.SyntaxKind.EqualsToken, value);
     }
     createBinaryExpression(leftOperand, operator, rightOperand) {
-        return ts.factory.createBinaryExpression(leftOperand, BINARY_OPERATORS[operator], rightOperand);
+        return typescript_1.default.factory.createBinaryExpression(leftOperand, BINARY_OPERATORS[operator], rightOperand);
     }
     createBlock(body) {
-        return ts.factory.createBlock(body);
+        return typescript_1.default.factory.createBlock(body);
     }
     createCallExpression(callee, args, pure) {
-        const call = ts.factory.createCallExpression(callee, undefined, args);
+        const call = typescript_1.default.factory.createCallExpression(callee, undefined, args);
         if (pure) {
-            ts.addSyntheticLeadingComment(call, ts.SyntaxKind.MultiLineCommentTrivia, this.annotateForClosureCompiler
+            typescript_1.default.addSyntheticLeadingComment(call, typescript_1.default.SyntaxKind.MultiLineCommentTrivia, this.annotateForClosureCompiler
                 ? PureAnnotation.CLOSURE
                 : PureAnnotation.TERSER, 
             /* trailing newline */ false);
@@ -112,57 +93,57 @@ class TypeScriptAstFactory {
         return call;
     }
     createConditional(condition, whenTrue, whenFalse) {
-        return ts.factory.createConditionalExpression(condition, undefined, whenTrue, undefined, whenFalse);
+        return typescript_1.default.factory.createConditionalExpression(condition, undefined, whenTrue, undefined, whenFalse);
     }
     createFunctionDeclaration(functionName, parameters, body) {
-        if (!ts.isBlock(body)) {
-            throw new Error(`Invalid syntax, expected a block, but got ${ts.SyntaxKind[body.kind]}.`);
+        if (!typescript_1.default.isBlock(body)) {
+            throw new Error(`Invalid syntax, expected a block, but got ${typescript_1.default.SyntaxKind[body.kind]}.`);
         }
-        return ts.factory.createFunctionDeclaration(undefined, undefined, undefined, functionName, undefined, parameters.map((param) => ts.factory.createParameterDeclaration(undefined, undefined, undefined, param)), undefined, body);
+        return (0, ts_compatibility_1.createFunctionDeclaration)(undefined, undefined, functionName, undefined, parameters.map((param) => (0, ts_compatibility_1.createParameterDeclaration)(undefined, undefined, param)), undefined, body);
     }
     createFunctionExpression(functionName, parameters, body) {
-        if (!ts.isBlock(body)) {
-            throw new Error(`Invalid syntax, expected a block, but got ${ts.SyntaxKind[body.kind]}.`);
+        if (!typescript_1.default.isBlock(body)) {
+            throw new Error(`Invalid syntax, expected a block, but got ${typescript_1.default.SyntaxKind[body.kind]}.`);
         }
-        return ts.factory.createFunctionExpression(undefined, undefined, functionName !== null && functionName !== void 0 ? functionName : undefined, undefined, parameters.map((param) => ts.factory.createParameterDeclaration(undefined, undefined, undefined, param)), undefined, body);
+        return typescript_1.default.factory.createFunctionExpression(undefined, undefined, functionName !== null && functionName !== void 0 ? functionName : undefined, undefined, parameters.map((param) => (0, ts_compatibility_1.createParameterDeclaration)(undefined, undefined, param)), undefined, body);
     }
     createIfStatement(condition, thenStatement, elseStatement) {
-        return ts.factory.createIfStatement(condition, thenStatement, elseStatement !== null && elseStatement !== void 0 ? elseStatement : undefined);
+        return typescript_1.default.factory.createIfStatement(condition, thenStatement, elseStatement !== null && elseStatement !== void 0 ? elseStatement : undefined);
     }
     createLiteral(value) {
         if (value === undefined) {
-            return ts.factory.createIdentifier('undefined');
+            return typescript_1.default.factory.createIdentifier('undefined');
         }
         else if (value === null) {
-            return ts.factory.createNull();
+            return typescript_1.default.factory.createNull();
         }
         else if (typeof value === 'boolean') {
-            return value ? ts.factory.createTrue() : ts.factory.createFalse();
+            return value ? typescript_1.default.factory.createTrue() : typescript_1.default.factory.createFalse();
         }
         else if (typeof value === 'number') {
-            return ts.factory.createNumericLiteral(value);
+            return typescript_1.default.factory.createNumericLiteral(value);
         }
         else {
-            return ts.factory.createStringLiteral(value);
+            return typescript_1.default.factory.createStringLiteral(value);
         }
     }
     createNewExpression(expression, args) {
-        return ts.factory.createNewExpression(expression, undefined, args);
+        return typescript_1.default.factory.createNewExpression(expression, undefined, args);
     }
     createObjectLiteral(properties) {
-        return ts.factory.createObjectLiteralExpression(properties.map((prop) => ts.factory.createPropertyAssignment(prop.quoted
-            ? ts.factory.createStringLiteral(prop.propertyName)
-            : ts.factory.createIdentifier(prop.propertyName), prop.value)));
+        return typescript_1.default.factory.createObjectLiteralExpression(properties.map((prop) => typescript_1.default.factory.createPropertyAssignment(prop.quoted
+            ? typescript_1.default.factory.createStringLiteral(prop.propertyName)
+            : typescript_1.default.factory.createIdentifier(prop.propertyName), prop.value)));
     }
     createReturnStatement(expression) {
-        return ts.factory.createReturnStatement(expression !== null && expression !== void 0 ? expression : undefined);
+        return typescript_1.default.factory.createReturnStatement(expression !== null && expression !== void 0 ? expression : undefined);
     }
     createTaggedTemplate(tag, template) {
         let templateLiteral;
         const length = template.elements.length;
         const head = template.elements[0];
         if (length === 1) {
-            templateLiteral = ts.factory.createNoSubstitutionTemplateLiteral(head.cooked, head.raw);
+            templateLiteral = typescript_1.default.factory.createNoSubstitutionTemplateLiteral(head.cooked, head.raw);
         }
         else {
             const spans = [];
@@ -173,7 +154,7 @@ class TypeScriptAstFactory {
                 if (range !== null) {
                     this.setSourceMapRange(middle, range);
                 }
-                spans.push(ts.factory.createTemplateSpan(template.expressions[i - 1], middle));
+                spans.push(typescript_1.default.factory.createTemplateSpan(template.expressions[i - 1], middle));
             }
             // Create the tail part
             const resolvedExpression = template.expressions[length - 2];
@@ -182,21 +163,21 @@ class TypeScriptAstFactory {
             if (templatePart.range !== null) {
                 this.setSourceMapRange(templateTail, templatePart.range);
             }
-            spans.push(ts.factory.createTemplateSpan(resolvedExpression, templateTail));
+            spans.push(typescript_1.default.factory.createTemplateSpan(resolvedExpression, templateTail));
             // Put it all together
-            templateLiteral = ts.factory.createTemplateExpression(ts.factory.createTemplateHead(head.cooked, head.raw), spans);
+            templateLiteral = typescript_1.default.factory.createTemplateExpression(typescript_1.default.factory.createTemplateHead(head.cooked, head.raw), spans);
         }
         if (head.range !== null) {
             this.setSourceMapRange(templateLiteral, head.range);
         }
-        return ts.factory.createTaggedTemplateExpression(tag, undefined, templateLiteral);
+        return typescript_1.default.factory.createTaggedTemplateExpression(tag, undefined, templateLiteral);
     }
     createUnaryExpression(operator, operand) {
-        return ts.factory.createPrefixUnaryExpression(UNARY_OPERATORS[operator], operand);
+        return typescript_1.default.factory.createPrefixUnaryExpression(UNARY_OPERATORS[operator], operand);
     }
     createVariableDeclaration(variableName, initializer, type) {
-        return ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
-            ts.factory.createVariableDeclaration(variableName, undefined, undefined, initializer !== null && initializer !== void 0 ? initializer : undefined),
+        return typescript_1.default.factory.createVariableStatement(undefined, typescript_1.default.factory.createVariableDeclarationList([
+            typescript_1.default.factory.createVariableDeclaration(variableName, undefined, undefined, initializer !== null && initializer !== void 0 ? initializer : undefined),
         ], VAR_TYPES[type]));
     }
     setSourceMapRange(node, sourceMapRange) {
@@ -205,10 +186,10 @@ class TypeScriptAstFactory {
         }
         const url = sourceMapRange.url;
         if (!this.externalSourceFiles.has(url)) {
-            this.externalSourceFiles.set(url, ts.createSourceMapSource(url, sourceMapRange.content, (pos) => pos));
+            this.externalSourceFiles.set(url, typescript_1.default.createSourceMapSource(url, sourceMapRange.content, (pos) => pos));
         }
         const source = this.externalSourceFiles.get(url);
-        ts.setSourceMapRange(node, {
+        typescript_1.default.setSourceMapRange(node, {
             pos: sourceMapRange.start.offset,
             end: sourceMapRange.end.offset,
             source,
@@ -220,16 +201,16 @@ exports.TypeScriptAstFactory = TypeScriptAstFactory;
 // HACK: Use this in place of `ts.createTemplateMiddle()`.
 // Revert once https://github.com/microsoft/TypeScript/issues/35374 is fixed.
 function createTemplateMiddle(cooked, raw) {
-    const node = ts.createTemplateHead(cooked, raw);
-    node.kind = ts.SyntaxKind.TemplateMiddle;
+    const node = typescript_1.default.factory.createTemplateHead(cooked, raw);
+    node.kind = typescript_1.default.SyntaxKind.TemplateMiddle;
     return node;
 }
 exports.createTemplateMiddle = createTemplateMiddle;
 // HACK: Use this in place of `ts.createTemplateTail()`.
 // Revert once https://github.com/microsoft/TypeScript/issues/35374 is fixed.
 function createTemplateTail(cooked, raw) {
-    const node = ts.factory.createTemplateHead(cooked, raw);
-    node.kind = ts.SyntaxKind.TemplateTail;
+    const node = typescript_1.default.factory.createTemplateHead(cooked, raw);
+    node.kind = typescript_1.default.SyntaxKind.TemplateTail;
     return node;
 }
 exports.createTemplateTail = createTemplateTail;
@@ -242,14 +223,14 @@ exports.createTemplateTail = createTemplateTail;
 function attachComments(statement, leadingComments) {
     for (const comment of leadingComments) {
         const commentKind = comment.multiline
-            ? ts.SyntaxKind.MultiLineCommentTrivia
-            : ts.SyntaxKind.SingleLineCommentTrivia;
+            ? typescript_1.default.SyntaxKind.MultiLineCommentTrivia
+            : typescript_1.default.SyntaxKind.SingleLineCommentTrivia;
         if (comment.multiline) {
-            ts.addSyntheticLeadingComment(statement, commentKind, comment.toString(), comment.trailingNewline);
+            typescript_1.default.addSyntheticLeadingComment(statement, commentKind, comment.toString(), comment.trailingNewline);
         }
         else {
             for (const line of comment.toString().split('\n')) {
-                ts.addSyntheticLeadingComment(statement, commentKind, line, comment.trailingNewline);
+                typescript_1.default.addSyntheticLeadingComment(statement, commentKind, line, comment.trailingNewline);
             }
         }
     }

package/transform/compiler-cli/src/ngtsc/translator/src/typescript_translator.d.ts

@@ -5,9 +5,9 @@
  * 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 o from "../../../../../compiler";
-import * as ts from "typescript";
-import { ImportGenerator } from "./api/import_generator";
-import { TranslatorOptions } from "./translator";
+import * as o from 'static-injector/transform/compiler';
+import ts from 'typescript';
+import { ImportGenerator } from './api/import_generator';
+import { TranslatorOptions } from './translator';
 export declare function translateExpression(expression: o.Expression, imports: ImportGenerator<ts.Expression>, options?: TranslatorOptions<ts.Expression>): ts.Expression;
 export declare function translateStatement(statement: o.Statement, imports: ImportGenerator<ts.Expression>, options?: TranslatorOptions<ts.Expression>): ts.Statement;

package/transform/compiler-cli/src/ngtsc/ts_compatibility/src/ts_cross_version_utils.d.ts

@@ -6,146 +6,40 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import ts from 'typescript';
-/** Equivalent of `ts.ModifierLike` which is only present in TS 4.8+. */
-export declare type ModifierLike = ts.Modifier | ts.Decorator;
-/** Type of `ts.factory.updateParameterDeclaration` in TS 4.8+. */
-declare type Ts48UpdateParameterDeclarationFn = (node: ts.ParameterDeclaration, modifiers: readonly ModifierLike[] | undefined, dotDotDotToken: ts.DotDotDotToken | undefined, name: string | ts.BindingName, questionToken: ts.QuestionToken | undefined, type: ts.TypeNode | undefined, initializer: ts.Expression | undefined) => ts.ParameterDeclaration;
+/** Type of `ts.factory.CreateParameterDeclaration` in TS 4.9+. */
+type Ts49CreateParameterDeclarationFn = (modifiers: readonly ts.ModifierLike[] | undefined, dotDotDotToken: ts.DotDotDotToken | undefined, name: string | ts.BindingName, questionToken?: ts.QuestionToken | undefined, type?: ts.TypeNode | undefined, initializer?: ts.Expression) => ts.ParameterDeclaration;
 /**
- * Updates a `ts.ParameterDeclaration` declaration.
+ * Creates a `ts.ParameterDeclaration` declaration.
  *
- * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.9.
  * We should remove it once we have dropped support for the older versions.
  */
-export declare const updateParameterDeclaration: Ts48UpdateParameterDeclarationFn;
-/** Type of `ts.factory.updateImportDeclaration` in TS 4.8+. */
-declare type Ts48UpdateImportDeclarationFn = (node: ts.ImportDeclaration, modifiers: readonly ts.Modifier[] | undefined, importClause: ts.ImportClause | undefined, moduleSpecifier: ts.Expression, assertClause: ts.AssertClause | undefined) => ts.ImportDeclaration;
+export declare const createParameterDeclaration: Ts49CreateParameterDeclarationFn;
+/** Type of `ts.factory.createImportDeclaration` in TS 4.9+. */
+type Ts49CreateImportDeclarationFn = (modifiers: readonly ts.Modifier[] | undefined, importClause: ts.ImportClause | undefined, moduleSpecifier: ts.Expression, assertClause?: ts.AssertClause) => ts.ImportDeclaration;
 /**
- * Updates a `ts.ImportDeclaration` declaration.
+ * Creates a `ts.ImportDeclaration` declaration.
  *
- * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.9.
  * We should remove it once we have dropped support for the older versions.
  */
-export declare const updateImportDeclaration: Ts48UpdateImportDeclarationFn;
-/** Type of `ts.factory.updateClassDeclaration` in TS 4.8+. */
-declare type Ts48UpdateClassDeclarationFn = (node: ts.ClassDeclaration, modifiers: readonly ModifierLike[] | undefined, name: ts.Identifier | undefined, typeParameters: readonly ts.TypeParameterDeclaration[] | undefined, heritageClauses: readonly ts.HeritageClause[] | undefined, members: readonly ts.ClassElement[]) => ts.ClassDeclaration;
+export declare const createImportDeclaration: Ts49CreateImportDeclarationFn;
+/** Type of `ts.factory.createFunctionDeclaration` in TS 4.9+. */
+type Ts49CreateFunctionDeclarationFn = (modifiers: readonly ts.ModifierLike[] | undefined, asteriskToken: ts.AsteriskToken | undefined, name: string | ts.Identifier | undefined, typeParameters: readonly ts.TypeParameterDeclaration[] | undefined, parameters: readonly ts.ParameterDeclaration[], type: ts.TypeNode | undefined, body: ts.Block | undefined) => ts.FunctionDeclaration;
 /**
- * Updates a `ts.ClassDeclaration` declaration.
+ * Creates a `ts.FunctionDeclaration` declaration.
  *
- * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.9.
  * We should remove it once we have dropped support for the older versions.
  */
-export declare const updateClassDeclaration: Ts48UpdateClassDeclarationFn;
-/** Type of `ts.factory.createClassDeclaration` in TS 4.8+. */
-declare type Ts48CreateClassDeclarationFn = (modifiers: readonly ModifierLike[] | undefined, name: ts.Identifier | undefined, typeParameters: readonly ts.TypeParameterDeclaration[] | undefined, heritageClauses: readonly ts.HeritageClause[] | undefined, members: readonly ts.ClassElement[]) => ts.ClassDeclaration;
+export declare const createFunctionDeclaration: Ts49CreateFunctionDeclarationFn;
+/** Type of `ts.factory.createIndexSignature` in TS 4.9+. */
+type Ts49CreateIndexSignatureFn = (modifiers: readonly ts.Modifier[] | undefined, parameters: readonly ts.ParameterDeclaration[], type: ts.TypeNode) => ts.IndexSignatureDeclaration;
 /**
- * Creates a `ts.ClassDeclaration` declaration.
+ * Creates a `ts.IndexSignatureDeclaration` declaration.
  *
- * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.9.
  * We should remove it once we have dropped support for the older versions.
  */
-export declare const createClassDeclaration: Ts48CreateClassDeclarationFn;
-/** Type of `ts.factory.updateMethodDeclaration` in TS 4.8+. */
-declare type Ts48UpdateMethodDeclarationFn = (node: ts.MethodDeclaration, modifiers: readonly ModifierLike[] | undefined, asteriskToken: ts.AsteriskToken | undefined, name: ts.PropertyName, questionToken: ts.QuestionToken | undefined, typeParameters: readonly ts.TypeParameterDeclaration[] | undefined, parameters: readonly ts.ParameterDeclaration[], type: ts.TypeNode | undefined, body: ts.Block | undefined) => ts.MethodDeclaration;
-/**
- * Updates a `ts.MethodDeclaration` declaration.
- *
- * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
- * We should remove it once we have dropped support for the older versions.
- */
-export declare const updateMethodDeclaration: Ts48UpdateMethodDeclarationFn;
-/** Type of `ts.factory.createMethodDeclaration` in TS 4.8+. */
-declare type Ts48CreateMethodDeclarationFn = (modifiers: readonly ModifierLike[] | undefined, asteriskToken: ts.AsteriskToken | undefined, name: ts.PropertyName, questionToken: ts.QuestionToken | undefined, typeParameters: readonly ts.TypeParameterDeclaration[] | undefined, parameters: readonly ts.ParameterDeclaration[], type: ts.TypeNode | undefined, body: ts.Block | undefined) => ts.MethodDeclaration;
-/**
- * Creates a `ts.MethodDeclaration` declaration.
- *
- * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
- * We should remove it once we have dropped support for the older versions.
- */
-export declare const createMethodDeclaration: Ts48CreateMethodDeclarationFn;
-/** Type of `ts.factory.updatePropertyDeclaration` in TS 4.8+. */
-declare type Ts48UpdatePropertyDeclarationFn = (node: ts.PropertyDeclaration, modifiers: readonly ModifierLike[] | undefined, name: string | ts.PropertyName, questionOrExclamationToken: ts.QuestionToken | ts.ExclamationToken | undefined, type: ts.TypeNode | undefined, initializer: ts.Expression | undefined) => ts.PropertyDeclaration;
-/**
- * Updates a `ts.PropertyDeclaration` declaration.
- *
- * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
- * We should remove it once we have dropped support for the older versions.
- */
-export declare const updatePropertyDeclaration: Ts48UpdatePropertyDeclarationFn;
-/** Type of `ts.factory.createPropertyDeclaration` in TS 4.8+. */
-declare type Ts48CreatePropertyDeclarationFn = (modifiers: readonly ModifierLike[] | undefined, name: string | ts.PropertyName, questionOrExclamationToken: ts.QuestionToken | ts.ExclamationToken | undefined, type: ts.TypeNode | undefined, initializer: ts.Expression | undefined) => ts.PropertyDeclaration;
-/**
- * Creates a `ts.PropertyDeclaration` declaration.
- *
- * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
- * We should remove it once we have dropped support for the older versions.
- */
-export declare const createPropertyDeclaration: Ts48CreatePropertyDeclarationFn;
-/** Type of `ts.factory.updateGetAccessorDeclaration` in TS 4.8+. */
-declare type Ts48UpdateGetAccessorDeclarationFn = (node: ts.GetAccessorDeclaration, modifiers: readonly ModifierLike[] | undefined, name: ts.PropertyName, parameters: readonly ts.ParameterDeclaration[], type: ts.TypeNode | undefined, body: ts.Block | undefined) => ts.GetAccessorDeclaration;
-/**
- * Updates a `ts.GetAccessorDeclaration` declaration.
- *
- * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
- * We should remove it once we have dropped support for the older versions.
- */
-export declare const updateGetAccessorDeclaration: Ts48UpdateGetAccessorDeclarationFn;
-/** Type of `ts.factory.createGetAccessorDeclaration` in TS 4.8+. */
-declare type Ts48CreateGetAccessorDeclarationFn = (modifiers: readonly ModifierLike[] | undefined, name: ts.PropertyName, parameters: readonly ts.ParameterDeclaration[], type: ts.TypeNode | undefined, body: ts.Block | undefined) => ts.GetAccessorDeclaration;
-/**
- * Creates a `ts.GetAccessorDeclaration` declaration.
- *
- * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
- * We should remove it once we have dropped support for the older versions.
- */
-export declare const createGetAccessorDeclaration: Ts48CreateGetAccessorDeclarationFn;
-/** Type of `ts.factory.updateSetAccessorDeclaration` in TS 4.8+. */
-declare type Ts48UpdateSetAccessorDeclarationFn = (node: ts.SetAccessorDeclaration, modifiers: readonly ModifierLike[] | undefined, name: ts.PropertyName, parameters: readonly ts.ParameterDeclaration[], body: ts.Block | undefined) => ts.SetAccessorDeclaration;
-/**
- * Updates a `ts.GetAccessorDeclaration` declaration.
- *
- * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
- * We should remove it once we have dropped support for the older versions.
- */
-export declare const updateSetAccessorDeclaration: Ts48UpdateSetAccessorDeclarationFn;
-/** Type of `ts.factory.createSetAccessorDeclaration` in TS 4.8+. */
-declare type Ts48CreateSetAccessorDeclarationFn = (modifiers: readonly ModifierLike[] | undefined, name: ts.PropertyName, parameters: readonly ts.ParameterDeclaration[], body: ts.Block | undefined) => ts.SetAccessorDeclaration;
-/**
- * Creates a `ts.GetAccessorDeclaration` declaration.
- *
- * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
- * We should remove it once we have dropped support for the older versions.
- */
-export declare const createSetAccessorDeclaration: Ts48CreateSetAccessorDeclarationFn;
-/** Type of `ts.factory.updateConstructorDeclaration` in TS 4.8+. */
-declare type Ts48UpdateConstructorDeclarationFn = (node: ts.ConstructorDeclaration, modifiers: readonly ts.Modifier[] | undefined, parameters: readonly ts.ParameterDeclaration[], body: ts.Block | undefined) => ts.ConstructorDeclaration;
-/**
- * Updates a `ts.ConstructorDeclaration` declaration.
- *
- * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
- * We should remove it once we have dropped support for the older versions.
- */
-export declare const updateConstructorDeclaration: Ts48UpdateConstructorDeclarationFn;
-/**
- * Gets the decorators that have been applied to a node.
- *
- * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
- * We should remove it once we have dropped support for the older versions.
- */
-export declare const getDecorators: (node: ts.Node) => readonly ts.Decorator[] | undefined;
-/**
- * Gets the modifiers that have been set on a node.
- *
- * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
- * We should remove it once we have dropped support for the older versions.
- */
-export declare const getModifiers: (node: ts.Node) => readonly ts.Modifier[] | undefined;
-/**
- * Combines an optional array of decorators with an optional array of modifiers into a single
- * `ts.ModifierLike` array. Used in version of TypeScript after 4.8 where the `decorators` and
- * `modifiers` arrays have been combined.
- *
- * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.8.
- * We should remove it once we have dropped support for the older versions.
- */
-export declare function combineModifiers(decorators: readonly ts.Decorator[] | undefined, modifiers: readonly ModifierLike[] | undefined): readonly ModifierLike[] | undefined;
+export declare const createIndexSignature: Ts49CreateIndexSignatureFn;
 export {};