microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2025-12-13 04:57:55 -06:00
Code Issues Packages Projects Releases 212 Wiki Activity

Remove outdated deprecations (#52314)

Browse Source
This commit is contained in:
Ron Buckton 2023-01-20 12:19:13 -05:00 committed by GitHub
parent 1e99934b29
commit f526e16b2d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
11 changed files with 0 additions and 5126 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1371
src/deprecatedCompat/4.0/nodeFactoryTopLevelExports.ts
View File

File diff suppressed because it is too large Load Diff

20
src/deprecatedCompat/4.0/renamedNodeTests.ts
View File

@ -1,20 +0,0 @@
import {
Node,
SyntaxKind,
TypeAssertion,
} from "../_namespaces/ts";
import { deprecate } from "../deprecate";
// DEPRECATION: Renamed node tests
// DEPRECATION PLAN:
// - soft: 4.0
// - warn: 4.1
// - error: TBD
/** @deprecated Use `isTypeAssertionExpression` instead. */
export const isTypeAssertion = deprecate(function isTypeAssertion(node: Node): node is TypeAssertion {
return node.kind === SyntaxKind.TypeAssertionExpression;
}, {
since: "4.0",
warnAfter: "4.1",
message: "Use `isTypeAssertionExpression` instead."
});

80
src/deprecatedCompat/4.2/abstractConstructorTypes.ts
View File

@ -1,80 +0,0 @@
import {
addNodeFactoryPatcher,
buildOverload,
ConstructorTypeNode,
factory,
Modifier,
NodeArray,
NodeFactory,
ParameterDeclaration,
TypeNode,
TypeParameterDeclaration,
} from "../_namespaces/ts";
// DEPRECATION: Overloads for createConstructorTypeNode/updateConstructorTypeNode that do not accept 'modifiers'
// DEPRECATION PLAN:
// - soft: 4.2
// - warn: 4.3
// - error: 5.0
declare module "../../compiler/types" {
// Module transform: converted from interface augmentation
export interface NodeFactory {
/** @deprecated Use the overload that accepts 'modifiers' */
createConstructorTypeNode(typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): ConstructorTypeNode;
/** @deprecated Use the overload that accepts 'modifiers' */
updateConstructorTypeNode(node: ConstructorTypeNode, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode): ConstructorTypeNode;
}
}
function patchNodeFactory(factory: NodeFactory) {
const {
createConstructorTypeNode,
updateConstructorTypeNode,
} = factory;
factory.createConstructorTypeNode = buildOverload("createConstructorTypeNode")
.overload({
0(modifiers: readonly Modifier[] | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): ConstructorTypeNode {
return createConstructorTypeNode(modifiers, typeParameters, parameters, type);
},
1(typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): ConstructorTypeNode {
return createConstructorTypeNode(/*modifiers*/ undefined, typeParameters, parameters, type);
},
})
.bind({
0: args => args.length === 4,
1: args => args.length === 3,
})
.deprecate({
1: { since: "4.2", warnAfter: "4.3", message: "Use the overload that accepts 'modifiers'" }
})
.finish();
factory.updateConstructorTypeNode = buildOverload("updateConstructorTypeNode")
.overload({
0(node: ConstructorTypeNode, modifiers: readonly Modifier[] | undefined, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode) {
return updateConstructorTypeNode(node, modifiers, typeParameters, parameters, type);
},
1(node: ConstructorTypeNode, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode) {
return updateConstructorTypeNode(node, node.modifiers, typeParameters, parameters, type);
}
})
.bind({
0: args => args.length === 5,
1: args => args.length === 4,
})
.deprecate({
1: { since: "4.2", warnAfter: "4.3", message: "Use the overload that accepts 'modifiers'" }
})
.finish();
}
// Patch `createNodeFactory` because it creates the factories that are provided to transformers
// in the public API.
addNodeFactoryPatcher(patchNodeFactory);
// Patch `ts.factory` because its public
patchNodeFactory(factory);

22
src/deprecatedCompat/4.2/renamedNodeTests.ts
View File

@ -1,22 +0,0 @@
import {
isMemberName,
MemberName,
Node,
} from "../_namespaces/ts";
import { deprecate } from "../deprecate";
// DEPRECATION: Renamed node tests
// DEPRECATION PLAN:
// - soft: 4.2
// - warn: 4.3
// - error: 5.0
/**
* @deprecated Use `isMemberName` instead.
*/
export const isIdentifierOrPrivateIdentifier = deprecate(function isIdentifierOrPrivateIdentifier(node: Node): node is MemberName {
return isMemberName(node);
}, {
since: "4.2",
warnAfter: "4.3",
message: "Use `isMemberName` instead."
});

102
src/deprecatedCompat/4.6/importTypeAssertions.ts
View File

@ -1,102 +0,0 @@
import {
addNodeFactoryPatcher,
buildOverload,
EntityName,
factory,
ImportTypeAssertionContainer,
ImportTypeNode,
isArray,
isEntityName,
isImportTypeAssertionContainer,
NodeFactory,
TypeNode,
} from "../_namespaces/ts";
// DEPRECATION: Overloads to createImportTypeNode/updateImportTypeNode that do not accept `assertions`
// DEPRECATION PLAN:
// - soft: 4.6
// - warn: 4.7
// - error: 5.0
declare module "../../compiler/types" {
// Module transform: converted from interface augmentation
export interface NodeFactory {
// NOTE: The following overload is not deprecated, but exists to ensure we don't mark `createImportTypeNode(argument)` as deprecated due to optional parameters.
createImportTypeNode(argument: TypeNode, assertions?: ImportTypeAssertionContainer, qualifier?: EntityName, typeArguments?: readonly TypeNode[], isTypeOf?: boolean): ImportTypeNode;
/** @deprecated Use the overload that accepts 'assertions' */
createImportTypeNode(argument: TypeNode, qualifier?: EntityName, typeArguments?: readonly TypeNode[], isTypeOf?: boolean): ImportTypeNode;
/** @deprecated Use the overload that accepts 'assertions' */
updateImportTypeNode(node: ImportTypeNode, argument: TypeNode, qualifier: EntityName | undefined, typeArguments: readonly TypeNode[] | undefined, isTypeOf?: boolean): ImportTypeNode;
}
}
function patchNodeFactory(factory: NodeFactory) {
const {
createImportTypeNode,
updateImportTypeNode,
} = factory;
factory.createImportTypeNode = buildOverload("createImportTypeNode")
.overload({
0(argument: TypeNode, assertions?: ImportTypeAssertionContainer, qualifier?: EntityName, typeArguments?: readonly TypeNode[], isTypeOf?: boolean): ImportTypeNode {
return createImportTypeNode(argument, assertions, qualifier, typeArguments, isTypeOf);
},
1(argument: TypeNode, qualifier?: EntityName, typeArguments?: readonly TypeNode[], isTypeOf?: boolean): ImportTypeNode {
return createImportTypeNode(argument, /*assertions*/ undefined, qualifier, typeArguments, isTypeOf);
},
})
.bind({
0: ([, assertions, qualifier, typeArguments, isTypeOf]) =>
(assertions === undefined || isImportTypeAssertionContainer(assertions)) &&
(qualifier === undefined || !isArray(qualifier)) &&
(typeArguments === undefined || isArray(typeArguments)) &&
(isTypeOf === undefined || typeof isTypeOf === "boolean"),
1: ([, qualifier, typeArguments, isTypeOf, other]) =>
(other === undefined) &&
(qualifier === undefined || isEntityName(qualifier)) &&
(typeArguments === undefined || isArray(typeArguments)) &&
(isTypeOf === undefined || typeof isTypeOf === "boolean"),
})
.deprecate({
1: { since: "4.6", warnAfter: "4.7", message: "Use the overload that accepts 'assertions'" }
})
.finish();
factory.updateImportTypeNode = buildOverload("updateImportTypeNode")
.overload({
0(node: ImportTypeNode, argument: TypeNode, assertions: ImportTypeAssertionContainer | undefined, qualifier: EntityName | undefined, typeArguments: readonly TypeNode[] | undefined, isTypeOf?: boolean): ImportTypeNode {
return updateImportTypeNode(node, argument, assertions, qualifier, typeArguments, isTypeOf);
},
1(node: ImportTypeNode, argument: TypeNode, qualifier: EntityName | undefined, typeArguments: readonly TypeNode[] | undefined, isTypeOf?: boolean): ImportTypeNode {
return updateImportTypeNode(node, argument, node.assertions, qualifier, typeArguments, isTypeOf);
},
})
.bind({
0: ([, , assertions, qualifier, typeArguments, isTypeOf]) =>
(assertions === undefined || isImportTypeAssertionContainer(assertions)) &&
(qualifier === undefined || !isArray(qualifier)) &&
(typeArguments === undefined || isArray(typeArguments)) &&
(isTypeOf === undefined || typeof isTypeOf === "boolean"),
1: ([, , qualifier, typeArguments, isTypeOf, other]) =>
(other === undefined) &&
(qualifier === undefined || isEntityName(qualifier)) &&
(typeArguments === undefined || isArray(typeArguments)) &&
(isTypeOf === undefined || typeof isTypeOf === "boolean"),
}).
deprecate({
1: { since: "4.6", warnAfter: "4.7", message: "Use the overload that accepts 'assertions'" }
})
.finish();
}
// Patch `createNodeFactory` because it creates the factories that are provided to transformers
// in the public API.
addNodeFactoryPatcher(patchNodeFactory);
// Patch `ts.factory` because its public
patchNodeFactory(factory);

85
src/deprecatedCompat/4.7/typeParameterModifiers.ts
View File

@ -1,85 +0,0 @@
import {
addNodeFactoryPatcher,
buildOverload,
factory,
Identifier,
isArray,
Modifier,
NodeFactory,
TypeNode,
TypeParameterDeclaration,
} from "../_namespaces/ts";
// DEPRECATION: Overloads to createTypeParameter/updateTypeParameter that does not accept `modifiers`
// DEPRECATION PLAN:
// - soft: 4.7
// - warn: 4.8
// - error: 5.0
declare module "../../compiler/types" {
// Module transform: converted from interface augmentation
export interface NodeFactory {
/** @deprecated Use the overload that accepts 'modifiers' */
createTypeParameterDeclaration(name: string | Identifier, constraint?: TypeNode, defaultType?: TypeNode): TypeParameterDeclaration;
/** @deprecated Use the overload that accepts 'modifiers' */
updateTypeParameterDeclaration(node: TypeParameterDeclaration, name: Identifier, constraint: TypeNode | undefined, defaultType: TypeNode | undefined): TypeParameterDeclaration;
}
}
function patchNodeFactory(factory: NodeFactory) {
const {
createTypeParameterDeclaration,
updateTypeParameterDeclaration,
} = factory;
factory.createTypeParameterDeclaration = buildOverload("createTypeParameterDeclaration")
.overload({
0(modifiers: readonly Modifier[] | undefined, name: string | Identifier, constraint?: TypeNode, defaultType?: TypeNode): TypeParameterDeclaration {
return createTypeParameterDeclaration(modifiers, name, constraint, defaultType);
},
1(name: string | Identifier, constraint?: TypeNode, defaultType?: TypeNode): TypeParameterDeclaration {
return createTypeParameterDeclaration(/*modifiers*/ undefined, name, constraint, defaultType);
},
})
.bind({
0: ([modifiers]) =>
(modifiers === undefined || isArray(modifiers)),
1: ([name]) =>
(name !== undefined && !isArray(name)),
})
.deprecate({
1: { since: "4.7", warnAfter: "4.8", message: "Use the overload that accepts 'modifiers'" }
})
.finish();
factory.updateTypeParameterDeclaration = buildOverload("updateTypeParameterDeclaration")
.overload({
0(node: TypeParameterDeclaration, modifiers: readonly Modifier[] | undefined, name: Identifier, constraint: TypeNode | undefined, defaultType: TypeNode | undefined): TypeParameterDeclaration {
return updateTypeParameterDeclaration(node, modifiers, name, constraint, defaultType);
},
1(node: TypeParameterDeclaration, name: Identifier, constraint: TypeNode | undefined, defaultType: TypeNode | undefined): TypeParameterDeclaration {
return updateTypeParameterDeclaration(node, node.modifiers, name, constraint, defaultType);
},
})
.bind({
0: ([, modifiers]) =>
(modifiers === undefined || isArray(modifiers)),
1: ([, name]) =>
(name !== undefined && !isArray(name)),
})
.deprecate({
1: { since: "4.7", warnAfter: "4.8", message: "Use the overload that accepts 'modifiers'" }
})
.finish();
}
// Patch `createNodeFactory` because it creates the factories that are provided to transformers
// in the public API.
addNodeFactoryPatcher(patchNodeFactory);
// Patch `ts.factory` because its public
patchNodeFactory(factory);

1499
src/deprecatedCompat/4.8/mergeDecoratorsAndModifiers.ts
View File

File diff suppressed because it is too large Load Diff

7
src/deprecatedCompat/_namespaces/ts.ts
View File

@ -2,11 +2,4 @@
export * from "../../compiler/_namespaces/ts";
export * from "../deprecations";
export * from "../4.0/nodeFactoryTopLevelExports";
export * from "../4.0/renamedNodeTests";
export * from "../4.2/renamedNodeTests";
export * from "../4.2/abstractConstructorTypes";
export * from "../4.6/importTypeAssertions";
export * from "../4.7/typeParameterModifiers";
export * from "../4.8/mergeDecoratorsAndModifiers";
export * from "../5.0/identifierProperties";

36
src/testRunner/unittests/factory.ts
View File

@ -1,6 +1,4 @@
import * as ts from "../_namespaces/ts";
import { setEnableDeprecationWarnings } from "../../deprecatedCompat/deprecate";
import { Modifier } from "../_namespaces/ts";
describe("unittests:: FactoryAPI", () => {
function assertSyntaxKind(node: ts.Node, expected: ts.SyntaxKind) {
@ -85,38 +83,4 @@ describe("unittests:: FactoryAPI", () => {
});
});
describe("deprecations", () => {
beforeEach(() => {
setEnableDeprecationWarnings(false);
});
afterEach(() => {
setEnableDeprecationWarnings(true);
});
// https://github.com/microsoft/TypeScript/issues/50259
it("deprecated createConstructorDeclaration overload does not throw", () => {
const body = ts.factory.createBlock([]);
assert.doesNotThrow(() => ts.factory.createConstructorDeclaration(
/*decorators*/ undefined,
/*modifiers*/ undefined,
/*parameters*/ [],
body,
));
});
// https://github.com/microsoft/TypeScript/issues/50259
it("deprecated updateConstructorDeclaration overload does not throw", () => {
const body = ts.factory.createBlock([]);
const ctor = ts.factory.createConstructorDeclaration(/*modifiers*/ undefined, [], body);
assert.doesNotThrow(() => ts.factory.updateConstructorDeclaration(
ctor,
ctor.decorators,
ctor.modifiers as readonly Modifier[] | undefined,
ctor.parameters,
ctor.body,
));
});
});
});

952
tests/baselines/reference/api/tsserverlibrary.d.ts vendored
View File

@ -4533,30 +4533,6 @@ declare namespace ts {
getLastToken(sourceFile?: SourceFile): Node | undefined;
forEachChild<T>(cbNode: (node: Node) => T | undefined, cbNodeArray?: (nodes: NodeArray<Node>) => T | undefined): T | undefined;
}
interface Node {
/**
* @deprecated `decorators` has been removed from `Node` and merged with `modifiers` on the `Node` subtypes that support them.
* Use `ts.canHaveDecorators()` to test whether a `Node` can have decorators.
* Use `ts.getDecorators()` to get the decorators of a `Node`.
*
* For example:
* ```ts
* const decorators = ts.canHaveDecorators(node) ? ts.getDecorators(node) : undefined;
* ```
*/
readonly decorators?: undefined;
/**
* @deprecated `modifiers` has been removed from `Node` and moved to the `Node` subtypes that support them.
* Use `ts.canHaveModifiers()` to test whether a `Node` can have modifiers.
* Use `ts.getModifiers()` to get the modifiers of a `Node`.
*
* For example:
* ```ts
* const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined;
* ```
*/
readonly modifiers?: NodeArray<ModifierLike> | undefined;
}
interface JSDocContainer extends Node {
_jsdocContainerBrand: any;
}
@ -4757,10 +4733,6 @@ declare namespace ts {
readonly questionToken?: QuestionToken;
readonly type?: TypeNode;
}
interface PropertySignature {
/** @deprecated A property signature cannot have an initializer */
readonly initializer?: Expression | undefined;
}
interface PropertyDeclaration extends ClassElement, JSDocContainer {
readonly kind: SyntaxKind.PropertyDeclaration;
readonly parent: ClassLikeDeclaration;
@ -4786,12 +4758,6 @@ declare namespace ts {
readonly name: PropertyName;
readonly initializer: Expression;
}
interface PropertyAssignment {
/** @deprecated A property assignment cannot have a question token */
readonly questionToken?: QuestionToken | undefined;
/** @deprecated A property assignment cannot have an exclamation token */
readonly exclamationToken?: ExclamationToken | undefined;
}
interface ShorthandPropertyAssignment extends ObjectLiteralElement, JSDocContainer {
readonly kind: SyntaxKind.ShorthandPropertyAssignment;
readonly parent: ObjectLiteralExpression;
@ -4799,14 +4765,6 @@ declare namespace ts {
readonly equalsToken?: EqualsToken;
readonly objectAssignmentInitializer?: Expression;
}
interface ShorthandPropertyAssignment {
/** @deprecated A shorthand property assignment cannot have modifiers */
readonly modifiers?: NodeArray<ModifierLike> | undefined;
/** @deprecated A shorthand property assignment cannot have a question token */
readonly questionToken?: QuestionToken | undefined;
/** @deprecated A shorthand property assignment cannot have an exclamation token */
readonly exclamationToken?: ExclamationToken | undefined;
}
interface SpreadAssignment extends ObjectLiteralElement, JSDocContainer {
readonly kind: SyntaxKind.SpreadAssignment;
readonly parent: ObjectLiteralExpression;
@ -4929,10 +4887,6 @@ declare namespace ts {
interface FunctionTypeNode extends FunctionOrConstructorTypeNodeBase, LocalsContainer {
readonly kind: SyntaxKind.FunctionType;
}
interface FunctionTypeNode {
/** @deprecated A function type cannot have modifiers */
readonly modifiers?: NodeArray<Modifier> | undefined;
}
interface ConstructorTypeNode extends FunctionOrConstructorTypeNodeBase, LocalsContainer {
readonly kind: SyntaxKind.ConstructorType;
readonly modifiers?: NodeArray<Modifier>;
@ -7984,179 +7938,6 @@ declare namespace ts {
createExternalModuleExport(exportName: Identifier): ExportDeclaration;
restoreOuterExpressions(outerExpression: Expression | undefined, innerExpression: Expression, kinds?: OuterExpressionKinds): Expression;
}
interface NodeFactory {
/** @deprecated Use the overload that accepts 'modifiers' */
createConstructorTypeNode(typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): ConstructorTypeNode;
/** @deprecated Use the overload that accepts 'modifiers' */
updateConstructorTypeNode(node: ConstructorTypeNode, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode): ConstructorTypeNode;
}
interface NodeFactory {
createImportTypeNode(argument: TypeNode, assertions?: ImportTypeAssertionContainer, qualifier?: EntityName, typeArguments?: readonly TypeNode[], isTypeOf?: boolean): ImportTypeNode;
/** @deprecated Use the overload that accepts 'assertions' */
createImportTypeNode(argument: TypeNode, qualifier?: EntityName, typeArguments?: readonly TypeNode[], isTypeOf?: boolean): ImportTypeNode;
/** @deprecated Use the overload that accepts 'assertions' */
updateImportTypeNode(node: ImportTypeNode, argument: TypeNode, qualifier: EntityName | undefined, typeArguments: readonly TypeNode[] | undefined, isTypeOf?: boolean): ImportTypeNode;
}
interface NodeFactory {
/** @deprecated Use the overload that accepts 'modifiers' */
createTypeParameterDeclaration(name: string | Identifier, constraint?: TypeNode, defaultType?: TypeNode): TypeParameterDeclaration;
/** @deprecated Use the overload that accepts 'modifiers' */
updateTypeParameterDeclaration(node: TypeParameterDeclaration, name: Identifier, constraint: TypeNode | undefined, defaultType: TypeNode | undefined): TypeParameterDeclaration;
}
interface NodeFactory {
/**
* @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
*/
createParameterDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | BindingName, questionToken?: QuestionToken, type?: TypeNode, initializer?: Expression): ParameterDeclaration;
/**
* @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
*/
updateParameterDeclaration(node: ParameterDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | BindingName, questionToken: QuestionToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): ParameterDeclaration;
/**
* @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
*/
createPropertyDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | PropertyName, questionOrExclamationToken: QuestionToken | ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): PropertyDeclaration;
/**
* @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
*/
updatePropertyDeclaration(node: PropertyDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | PropertyName, questionOrExclamationToken: QuestionToken | ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): PropertyDeclaration;
/**
* @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
*/
createMethodDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: string | PropertyName, questionToken: QuestionToken | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): MethodDeclaration;
/**
* @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
*/
updateMethodDeclaration(node: MethodDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: PropertyName, questionToken: QuestionToken | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): MethodDeclaration;
/**
* @deprecated This node does not support Decorators. Callers should use an overload that does not accept a `decorators` parameter.
*/
createConstructorDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], body: Block | undefined): ConstructorDeclaration;
/**
* @deprecated This node does not support Decorators. Callers should use an overload that does not accept a `decorators` parameter.
*/
updateConstructorDeclaration(node: ConstructorDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], body: Block | undefined): ConstructorDeclaration;
/**
* @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
*/
createGetAccessorDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | PropertyName, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): GetAccessorDeclaration;
/**
* @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
*/
updateGetAccessorDeclaration(node: GetAccessorDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: PropertyName, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): GetAccessorDeclaration;
/**
* @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
*/
createSetAccessorDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | PropertyName, parameters: readonly ParameterDeclaration[], body: Block | undefined): SetAccessorDeclaration;
/**
* @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
*/
updateSetAccessorDeclaration(node: SetAccessorDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: PropertyName, parameters: readonly ParameterDeclaration[], body: Block | undefined): SetAccessorDeclaration;
/**
* @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
*/
createIndexSignature(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): IndexSignatureDeclaration;
/**
* @deprecated Decorators and modifiers are no longer supported for this function. Callers should use an overload that does not accept the `decorators` and `modifiers` parameters.
*/
updateIndexSignature(node: IndexSignatureDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): IndexSignatureDeclaration;
/**
* @deprecated Decorators and modifiers are no longer supported for this function. Callers should use an overload that does not accept the `decorators` and `modifiers` parameters.
*/
createClassStaticBlockDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, body: Block): ClassStaticBlockDeclaration;
/**
* @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
*/
updateClassStaticBlockDeclaration(node: ClassStaticBlockDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, body: Block): ClassStaticBlockDeclaration;
/**
* @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
*/
createClassExpression(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassExpression;
/**
* @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
*/
updateClassExpression(node: ClassExpression, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassExpression;
/**
* @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
*/
createFunctionDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): FunctionDeclaration;
/**
* @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
*/
updateFunctionDeclaration(node: FunctionDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): FunctionDeclaration;
/**
* @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
*/
createClassDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassDeclaration;
/**
* @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
*/
updateClassDeclaration(node: ClassDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassDeclaration;
/**
* @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
*/
createInterfaceDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly TypeElement[]): InterfaceDeclaration;
/**
* @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
*/
updateInterfaceDeclaration(node: InterfaceDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly TypeElement[]): InterfaceDeclaration;
/**
* @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
*/
createTypeAliasDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, type: TypeNode): TypeAliasDeclaration;
/**
* @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
*/
updateTypeAliasDeclaration(node: TypeAliasDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, type: TypeNode): TypeAliasDeclaration;
/**
* @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
*/
createEnumDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, members: readonly EnumMember[]): EnumDeclaration;
/**
* @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
*/
updateEnumDeclaration(node: EnumDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, members: readonly EnumMember[]): EnumDeclaration;
/**
* @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
*/
createModuleDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: ModuleName, body: ModuleBody | undefined, flags?: NodeFlags): ModuleDeclaration;
/**
* @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
*/
updateModuleDeclaration(node: ModuleDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: ModuleName, body: ModuleBody | undefined): ModuleDeclaration;
/**
* @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
*/
createImportEqualsDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, name: string | Identifier, moduleReference: ModuleReference): ImportEqualsDeclaration;
/**
* @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
*/
updateImportEqualsDeclaration(node: ImportEqualsDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, name: Identifier, moduleReference: ModuleReference): ImportEqualsDeclaration;
/**
* @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
*/
createImportDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause?: AssertClause): ImportDeclaration;
/**
* @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
*/
updateImportDeclaration(node: ImportDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration;
/**
* @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
*/
createExportAssignment(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isExportEquals: boolean | undefined, expression: Expression): ExportAssignment;
/**
* @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
*/
updateExportAssignment(node: ExportAssignment, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, expression: Expression): ExportAssignment;
/**
* @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
*/
createExportDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, exportClause: NamedExportBindings | undefined, moduleSpecifier?: Expression, assertClause?: AssertClause): ExportDeclaration;
/**
* @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
*/
updateExportDeclaration(node: ExportDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, exportClause: NamedExportBindings | undefined, moduleSpecifier: Expression | undefined, assertClause: AssertClause | undefined): ExportDeclaration;
}
interface CoreTransformationContext {
readonly factory: NodeFactory;
/** Gets the compiler options supplied to the transformer. */
@ -11218,738 +10999,5 @@ declare namespace ts {
* @param compilerOptions Optional compiler options.
*/
function transform<T extends Node>(source: T | T[], transformers: TransformerFactory<T>[], compilerOptions?: CompilerOptions): TransformationResult<T>;
/** @deprecated Use `factory.createNodeArray` or the factory supplied by your transformation context instead. */
const createNodeArray: typeof factory.createNodeArray;
/** @deprecated Use `factory.createNumericLiteral` or the factory supplied by your transformation context instead. */
const createNumericLiteral: typeof factory.createNumericLiteral;
/** @deprecated Use `factory.createBigIntLiteral` or the factory supplied by your transformation context instead. */
const createBigIntLiteral: typeof factory.createBigIntLiteral;
/** @deprecated Use `factory.createStringLiteral` or the factory supplied by your transformation context instead. */
const createStringLiteral: typeof factory.createStringLiteral;
/** @deprecated Use `factory.createStringLiteralFromNode` or the factory supplied by your transformation context instead. */
const createStringLiteralFromNode: typeof factory.createStringLiteralFromNode;
/** @deprecated Use `factory.createRegularExpressionLiteral` or the factory supplied by your transformation context instead. */
const createRegularExpressionLiteral: typeof factory.createRegularExpressionLiteral;
/** @deprecated Use `factory.createLoopVariable` or the factory supplied by your transformation context instead. */
const createLoopVariable: typeof factory.createLoopVariable;
/** @deprecated Use `factory.createUniqueName` or the factory supplied by your transformation context instead. */
const createUniqueName: typeof factory.createUniqueName;
/** @deprecated Use `factory.createPrivateIdentifier` or the factory supplied by your transformation context instead. */
const createPrivateIdentifier: typeof factory.createPrivateIdentifier;
/** @deprecated Use `factory.createSuper` or the factory supplied by your transformation context instead. */
const createSuper: typeof factory.createSuper;
/** @deprecated Use `factory.createThis` or the factory supplied by your transformation context instead. */
const createThis: typeof factory.createThis;
/** @deprecated Use `factory.createNull` or the factory supplied by your transformation context instead. */
const createNull: typeof factory.createNull;
/** @deprecated Use `factory.createTrue` or the factory supplied by your transformation context instead. */
const createTrue: typeof factory.createTrue;
/** @deprecated Use `factory.createFalse` or the factory supplied by your transformation context instead. */
const createFalse: typeof factory.createFalse;
/** @deprecated Use `factory.createModifier` or the factory supplied by your transformation context instead. */
const createModifier: typeof factory.createModifier;
/** @deprecated Use `factory.createModifiersFromModifierFlags` or the factory supplied by your transformation context instead. */
const createModifiersFromModifierFlags: typeof factory.createModifiersFromModifierFlags;
/** @deprecated Use `factory.createQualifiedName` or the factory supplied by your transformation context instead. */
const createQualifiedName: typeof factory.createQualifiedName;
/** @deprecated Use `factory.updateQualifiedName` or the factory supplied by your transformation context instead. */
const updateQualifiedName: typeof factory.updateQualifiedName;
/** @deprecated Use `factory.createComputedPropertyName` or the factory supplied by your transformation context instead. */
const createComputedPropertyName: typeof factory.createComputedPropertyName;
/** @deprecated Use `factory.updateComputedPropertyName` or the factory supplied by your transformation context instead. */
const updateComputedPropertyName: typeof factory.updateComputedPropertyName;
/** @deprecated Use `factory.createTypeParameterDeclaration` or the factory supplied by your transformation context instead. */
const createTypeParameterDeclaration: typeof factory.createTypeParameterDeclaration;
/** @deprecated Use `factory.updateTypeParameterDeclaration` or the factory supplied by your transformation context instead. */
const updateTypeParameterDeclaration: typeof factory.updateTypeParameterDeclaration;
/** @deprecated Use `factory.createParameterDeclaration` or the factory supplied by your transformation context instead. */
const createParameter: typeof factory.createParameterDeclaration;
/** @deprecated Use `factory.updateParameterDeclaration` or the factory supplied by your transformation context instead. */
const updateParameter: typeof factory.updateParameterDeclaration;
/** @deprecated Use `factory.createDecorator` or the factory supplied by your transformation context instead. */
const createDecorator: typeof factory.createDecorator;
/** @deprecated Use `factory.updateDecorator` or the factory supplied by your transformation context instead. */
const updateDecorator: typeof factory.updateDecorator;
/** @deprecated Use `factory.createPropertyDeclaration` or the factory supplied by your transformation context instead. */
const createProperty: typeof factory.createPropertyDeclaration;
/** @deprecated Use `factory.updatePropertyDeclaration` or the factory supplied by your transformation context instead. */
const updateProperty: typeof factory.updatePropertyDeclaration;
/** @deprecated Use `factory.createMethodDeclaration` or the factory supplied by your transformation context instead. */
const createMethod: typeof factory.createMethodDeclaration;
/** @deprecated Use `factory.updateMethodDeclaration` or the factory supplied by your transformation context instead. */
const updateMethod: typeof factory.updateMethodDeclaration;
/** @deprecated Use `factory.createConstructorDeclaration` or the factory supplied by your transformation context instead. */
const createConstructor: typeof factory.createConstructorDeclaration;
/** @deprecated Use `factory.updateConstructorDeclaration` or the factory supplied by your transformation context instead. */
const updateConstructor: typeof factory.updateConstructorDeclaration;
/** @deprecated Use `factory.createGetAccessorDeclaration` or the factory supplied by your transformation context instead. */
const createGetAccessor: typeof factory.createGetAccessorDeclaration;
/** @deprecated Use `factory.updateGetAccessorDeclaration` or the factory supplied by your transformation context instead. */
const updateGetAccessor: typeof factory.updateGetAccessorDeclaration;
/** @deprecated Use `factory.createSetAccessorDeclaration` or the factory supplied by your transformation context instead. */
const createSetAccessor: typeof factory.createSetAccessorDeclaration;
/** @deprecated Use `factory.updateSetAccessorDeclaration` or the factory supplied by your transformation context instead. */
const updateSetAccessor: typeof factory.updateSetAccessorDeclaration;
/** @deprecated Use `factory.createCallSignature` or the factory supplied by your transformation context instead. */
const createCallSignature: typeof factory.createCallSignature;
/** @deprecated Use `factory.updateCallSignature` or the factory supplied by your transformation context instead. */
const updateCallSignature: typeof factory.updateCallSignature;
/** @deprecated Use `factory.createConstructSignature` or the factory supplied by your transformation context instead. */
const createConstructSignature: typeof factory.createConstructSignature;
/** @deprecated Use `factory.updateConstructSignature` or the factory supplied by your transformation context instead. */
const updateConstructSignature: typeof factory.updateConstructSignature;
/** @deprecated Use `factory.updateIndexSignature` or the factory supplied by your transformation context instead. */
const updateIndexSignature: typeof factory.updateIndexSignature;
/** @deprecated Use `factory.createKeywordTypeNode` or the factory supplied by your transformation context instead. */
const createKeywordTypeNode: typeof factory.createKeywordTypeNode;
/** @deprecated Use `factory.createTypePredicateNode` or the factory supplied by your transformation context instead. */
const createTypePredicateNodeWithModifier: typeof factory.createTypePredicateNode;
/** @deprecated Use `factory.updateTypePredicateNode` or the factory supplied by your transformation context instead. */
const updateTypePredicateNodeWithModifier: typeof factory.updateTypePredicateNode;
/** @deprecated Use `factory.createTypeReferenceNode` or the factory supplied by your transformation context instead. */
const createTypeReferenceNode: typeof factory.createTypeReferenceNode;
/** @deprecated Use `factory.updateTypeReferenceNode` or the factory supplied by your transformation context instead. */
const updateTypeReferenceNode: typeof factory.updateTypeReferenceNode;
/** @deprecated Use `factory.createFunctionTypeNode` or the factory supplied by your transformation context instead. */
const createFunctionTypeNode: typeof factory.createFunctionTypeNode;
/** @deprecated Use `factory.updateFunctionTypeNode` or the factory supplied by your transformation context instead. */
const updateFunctionTypeNode: typeof factory.updateFunctionTypeNode;
/** @deprecated Use `factory.createConstructorTypeNode` or the factory supplied by your transformation context instead. */
const createConstructorTypeNode: (typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode) => ConstructorTypeNode;
/** @deprecated Use `factory.updateConstructorTypeNode` or the factory supplied by your transformation context instead. */
const updateConstructorTypeNode: (node: ConstructorTypeNode, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode) => ConstructorTypeNode;
/** @deprecated Use `factory.createTypeQueryNode` or the factory supplied by your transformation context instead. */
const createTypeQueryNode: typeof factory.createTypeQueryNode;
/** @deprecated Use `factory.updateTypeQueryNode` or the factory supplied by your transformation context instead. */
const updateTypeQueryNode: typeof factory.updateTypeQueryNode;
/** @deprecated Use `factory.createTypeLiteralNode` or the factory supplied by your transformation context instead. */
const createTypeLiteralNode: typeof factory.createTypeLiteralNode;
/** @deprecated Use `factory.updateTypeLiteralNode` or the factory supplied by your transformation context instead. */
const updateTypeLiteralNode: typeof factory.updateTypeLiteralNode;
/** @deprecated Use `factory.createArrayTypeNode` or the factory supplied by your transformation context instead. */
const createArrayTypeNode: typeof factory.createArrayTypeNode;
/** @deprecated Use `factory.updateArrayTypeNode` or the factory supplied by your transformation context instead. */
const updateArrayTypeNode: typeof factory.updateArrayTypeNode;
/** @deprecated Use `factory.createTupleTypeNode` or the factory supplied by your transformation context instead. */
const createTupleTypeNode: typeof factory.createTupleTypeNode;
/** @deprecated Use `factory.updateTupleTypeNode` or the factory supplied by your transformation context instead. */
const updateTupleTypeNode: typeof factory.updateTupleTypeNode;
/** @deprecated Use `factory.createOptionalTypeNode` or the factory supplied by your transformation context instead. */
const createOptionalTypeNode: typeof factory.createOptionalTypeNode;
/** @deprecated Use `factory.updateOptionalTypeNode` or the factory supplied by your transformation context instead. */
const updateOptionalTypeNode: typeof factory.updateOptionalTypeNode;
/** @deprecated Use `factory.createRestTypeNode` or the factory supplied by your transformation context instead. */
const createRestTypeNode: typeof factory.createRestTypeNode;
/** @deprecated Use `factory.updateRestTypeNode` or the factory supplied by your transformation context instead. */
const updateRestTypeNode: typeof factory.updateRestTypeNode;
/** @deprecated Use `factory.createUnionTypeNode` or the factory supplied by your transformation context instead. */
const createUnionTypeNode: typeof factory.createUnionTypeNode;
/** @deprecated Use `factory.updateUnionTypeNode` or the factory supplied by your transformation context instead. */
const updateUnionTypeNode: typeof factory.updateUnionTypeNode;
/** @deprecated Use `factory.createIntersectionTypeNode` or the factory supplied by your transformation context instead. */
const createIntersectionTypeNode: typeof factory.createIntersectionTypeNode;
/** @deprecated Use `factory.updateIntersectionTypeNode` or the factory supplied by your transformation context instead. */
const updateIntersectionTypeNode: typeof factory.updateIntersectionTypeNode;
/** @deprecated Use `factory.createConditionalTypeNode` or the factory supplied by your transformation context instead. */
const createConditionalTypeNode: typeof factory.createConditionalTypeNode;
/** @deprecated Use `factory.updateConditionalTypeNode` or the factory supplied by your transformation context instead. */
const updateConditionalTypeNode: typeof factory.updateConditionalTypeNode;
/** @deprecated Use `factory.createInferTypeNode` or the factory supplied by your transformation context instead. */
const createInferTypeNode: typeof factory.createInferTypeNode;
/** @deprecated Use `factory.updateInferTypeNode` or the factory supplied by your transformation context instead. */
const updateInferTypeNode: typeof factory.updateInferTypeNode;
/** @deprecated Use `factory.createImportTypeNode` or the factory supplied by your transformation context instead. */
const createImportTypeNode: typeof factory.createImportTypeNode;
/** @deprecated Use `factory.updateImportTypeNode` or the factory supplied by your transformation context instead. */
const updateImportTypeNode: typeof factory.updateImportTypeNode;
/** @deprecated Use `factory.createParenthesizedType` or the factory supplied by your transformation context instead. */
const createParenthesizedType: typeof factory.createParenthesizedType;
/** @deprecated Use `factory.updateParenthesizedType` or the factory supplied by your transformation context instead. */
const updateParenthesizedType: typeof factory.updateParenthesizedType;
/** @deprecated Use `factory.createThisTypeNode` or the factory supplied by your transformation context instead. */
const createThisTypeNode: typeof factory.createThisTypeNode;
/** @deprecated Use `factory.updateTypeOperatorNode` or the factory supplied by your transformation context instead. */
const updateTypeOperatorNode: typeof factory.updateTypeOperatorNode;
/** @deprecated Use `factory.createIndexedAccessTypeNode` or the factory supplied by your transformation context instead. */
const createIndexedAccessTypeNode: typeof factory.createIndexedAccessTypeNode;
/** @deprecated Use `factory.updateIndexedAccessTypeNode` or the factory supplied by your transformation context instead. */
const updateIndexedAccessTypeNode: typeof factory.updateIndexedAccessTypeNode;
/** @deprecated Use `factory.createMappedTypeNode` or the factory supplied by your transformation context instead. */
const createMappedTypeNode: typeof factory.createMappedTypeNode;
/** @deprecated Use `factory.updateMappedTypeNode` or the factory supplied by your transformation context instead. */
const updateMappedTypeNode: typeof factory.updateMappedTypeNode;
/** @deprecated Use `factory.createLiteralTypeNode` or the factory supplied by your transformation context instead. */
const createLiteralTypeNode: typeof factory.createLiteralTypeNode;
/** @deprecated Use `factory.updateLiteralTypeNode` or the factory supplied by your transformation context instead. */
const updateLiteralTypeNode: typeof factory.updateLiteralTypeNode;
/** @deprecated Use `factory.createObjectBindingPattern` or the factory supplied by your transformation context instead. */
const createObjectBindingPattern: typeof factory.createObjectBindingPattern;
/** @deprecated Use `factory.updateObjectBindingPattern` or the factory supplied by your transformation context instead. */
const updateObjectBindingPattern: typeof factory.updateObjectBindingPattern;
/** @deprecated Use `factory.createArrayBindingPattern` or the factory supplied by your transformation context instead. */
const createArrayBindingPattern: typeof factory.createArrayBindingPattern;
/** @deprecated Use `factory.updateArrayBindingPattern` or the factory supplied by your transformation context instead. */
const updateArrayBindingPattern: typeof factory.updateArrayBindingPattern;
/** @deprecated Use `factory.createBindingElement` or the factory supplied by your transformation context instead. */
const createBindingElement: typeof factory.createBindingElement;
/** @deprecated Use `factory.updateBindingElement` or the factory supplied by your transformation context instead. */
const updateBindingElement: typeof factory.updateBindingElement;
/** @deprecated Use `factory.createArrayLiteralExpression` or the factory supplied by your transformation context instead. */
const createArrayLiteral: typeof factory.createArrayLiteralExpression;
/** @deprecated Use `factory.updateArrayLiteralExpression` or the factory supplied by your transformation context instead. */
const updateArrayLiteral: typeof factory.updateArrayLiteralExpression;
/** @deprecated Use `factory.createObjectLiteralExpression` or the factory supplied by your transformation context instead. */
const createObjectLiteral: typeof factory.createObjectLiteralExpression;
/** @deprecated Use `factory.updateObjectLiteralExpression` or the factory supplied by your transformation context instead. */
const updateObjectLiteral: typeof factory.updateObjectLiteralExpression;
/** @deprecated Use `factory.createPropertyAccessExpression` or the factory supplied by your transformation context instead. */
const createPropertyAccess: typeof factory.createPropertyAccessExpression;
/** @deprecated Use `factory.updatePropertyAccessExpression` or the factory supplied by your transformation context instead. */
const updatePropertyAccess: typeof factory.updatePropertyAccessExpression;
/** @deprecated Use `factory.createPropertyAccessChain` or the factory supplied by your transformation context instead. */
const createPropertyAccessChain: typeof factory.createPropertyAccessChain;
/** @deprecated Use `factory.updatePropertyAccessChain` or the factory supplied by your transformation context instead. */
const updatePropertyAccessChain: typeof factory.updatePropertyAccessChain;
/** @deprecated Use `factory.createElementAccessExpression` or the factory supplied by your transformation context instead. */
const createElementAccess: typeof factory.createElementAccessExpression;
/** @deprecated Use `factory.updateElementAccessExpression` or the factory supplied by your transformation context instead. */
const updateElementAccess: typeof factory.updateElementAccessExpression;
/** @deprecated Use `factory.createElementAccessChain` or the factory supplied by your transformation context instead. */
const createElementAccessChain: typeof factory.createElementAccessChain;
/** @deprecated Use `factory.updateElementAccessChain` or the factory supplied by your transformation context instead. */
const updateElementAccessChain: typeof factory.updateElementAccessChain;
/** @deprecated Use `factory.createCallExpression` or the factory supplied by your transformation context instead. */
const createCall: typeof factory.createCallExpression;
/** @deprecated Use `factory.updateCallExpression` or the factory supplied by your transformation context instead. */
const updateCall: typeof factory.updateCallExpression;
/** @deprecated Use `factory.createCallChain` or the factory supplied by your transformation context instead. */
const createCallChain: typeof factory.createCallChain;
/** @deprecated Use `factory.updateCallChain` or the factory supplied by your transformation context instead. */
const updateCallChain: typeof factory.updateCallChain;
/** @deprecated Use `factory.createNewExpression` or the factory supplied by your transformation context instead. */
const createNew: typeof factory.createNewExpression;
/** @deprecated Use `factory.updateNewExpression` or the factory supplied by your transformation context instead. */
const updateNew: typeof factory.updateNewExpression;
/** @deprecated Use `factory.createTypeAssertion` or the factory supplied by your transformation context instead. */
const createTypeAssertion: typeof factory.createTypeAssertion;
/** @deprecated Use `factory.updateTypeAssertion` or the factory supplied by your transformation context instead. */
const updateTypeAssertion: typeof factory.updateTypeAssertion;
/** @deprecated Use `factory.createParenthesizedExpression` or the factory supplied by your transformation context instead. */
const createParen: typeof factory.createParenthesizedExpression;
/** @deprecated Use `factory.updateParenthesizedExpression` or the factory supplied by your transformation context instead. */
const updateParen: typeof factory.updateParenthesizedExpression;
/** @deprecated Use `factory.createFunctionExpression` or the factory supplied by your transformation context instead. */
const createFunctionExpression: typeof factory.createFunctionExpression;
/** @deprecated Use `factory.updateFunctionExpression` or the factory supplied by your transformation context instead. */
const updateFunctionExpression: typeof factory.updateFunctionExpression;
/** @deprecated Use `factory.createDeleteExpression` or the factory supplied by your transformation context instead. */
const createDelete: typeof factory.createDeleteExpression;
/** @deprecated Use `factory.updateDeleteExpression` or the factory supplied by your transformation context instead. */
const updateDelete: typeof factory.updateDeleteExpression;
/** @deprecated Use `factory.createTypeOfExpression` or the factory supplied by your transformation context instead. */
const createTypeOf: typeof factory.createTypeOfExpression;
/** @deprecated Use `factory.updateTypeOfExpression` or the factory supplied by your transformation context instead. */
const updateTypeOf: typeof factory.updateTypeOfExpression;
/** @deprecated Use `factory.createVoidExpression` or the factory supplied by your transformation context instead. */
const createVoid: typeof factory.createVoidExpression;
/** @deprecated Use `factory.updateVoidExpression` or the factory supplied by your transformation context instead. */
const updateVoid: typeof factory.updateVoidExpression;
/** @deprecated Use `factory.createAwaitExpression` or the factory supplied by your transformation context instead. */
const createAwait: typeof factory.createAwaitExpression;
/** @deprecated Use `factory.updateAwaitExpression` or the factory supplied by your transformation context instead. */
const updateAwait: typeof factory.updateAwaitExpression;
/** @deprecated Use `factory.createPrefixExpression` or the factory supplied by your transformation context instead. */
const createPrefix: typeof factory.createPrefixUnaryExpression;
/** @deprecated Use `factory.updatePrefixExpression` or the factory supplied by your transformation context instead. */
const updatePrefix: typeof factory.updatePrefixUnaryExpression;
/** @deprecated Use `factory.createPostfixUnaryExpression` or the factory supplied by your transformation context instead. */
const createPostfix: typeof factory.createPostfixUnaryExpression;
/** @deprecated Use `factory.updatePostfixUnaryExpression` or the factory supplied by your transformation context instead. */
const updatePostfix: typeof factory.updatePostfixUnaryExpression;
/** @deprecated Use `factory.createBinaryExpression` or the factory supplied by your transformation context instead. */
const createBinary: typeof factory.createBinaryExpression;
/** @deprecated Use `factory.updateConditionalExpression` or the factory supplied by your transformation context instead. */
const updateConditional: typeof factory.updateConditionalExpression;
/** @deprecated Use `factory.createTemplateExpression` or the factory supplied by your transformation context instead. */
const createTemplateExpression: typeof factory.createTemplateExpression;
/** @deprecated Use `factory.updateTemplateExpression` or the factory supplied by your transformation context instead. */
const updateTemplateExpression: typeof factory.updateTemplateExpression;
/** @deprecated Use `factory.createTemplateHead` or the factory supplied by your transformation context instead. */
const createTemplateHead: typeof factory.createTemplateHead;
/** @deprecated Use `factory.createTemplateMiddle` or the factory supplied by your transformation context instead. */
const createTemplateMiddle: typeof factory.createTemplateMiddle;
/** @deprecated Use `factory.createTemplateTail` or the factory supplied by your transformation context instead. */
const createTemplateTail: typeof factory.createTemplateTail;
/** @deprecated Use `factory.createNoSubstitutionTemplateLiteral` or the factory supplied by your transformation context instead. */
const createNoSubstitutionTemplateLiteral: typeof factory.createNoSubstitutionTemplateLiteral;
/** @deprecated Use `factory.updateYieldExpression` or the factory supplied by your transformation context instead. */
const updateYield: typeof factory.updateYieldExpression;
/** @deprecated Use `factory.createSpreadExpression` or the factory supplied by your transformation context instead. */
const createSpread: typeof factory.createSpreadElement;
/** @deprecated Use `factory.updateSpreadExpression` or the factory supplied by your transformation context instead. */
const updateSpread: typeof factory.updateSpreadElement;
/** @deprecated Use `factory.createOmittedExpression` or the factory supplied by your transformation context instead. */
const createOmittedExpression: typeof factory.createOmittedExpression;
/** @deprecated Use `factory.createAsExpression` or the factory supplied by your transformation context instead. */
const createAsExpression: typeof factory.createAsExpression;
/** @deprecated Use `factory.updateAsExpression` or the factory supplied by your transformation context instead. */
const updateAsExpression: typeof factory.updateAsExpression;
/** @deprecated Use `factory.createNonNullExpression` or the factory supplied by your transformation context instead. */
const createNonNullExpression: typeof factory.createNonNullExpression;
/** @deprecated Use `factory.updateNonNullExpression` or the factory supplied by your transformation context instead. */
const updateNonNullExpression: typeof factory.updateNonNullExpression;
/** @deprecated Use `factory.createNonNullChain` or the factory supplied by your transformation context instead. */
const createNonNullChain: typeof factory.createNonNullChain;
/** @deprecated Use `factory.updateNonNullChain` or the factory supplied by your transformation context instead. */
const updateNonNullChain: typeof factory.updateNonNullChain;
/** @deprecated Use `factory.createMetaProperty` or the factory supplied by your transformation context instead. */
const createMetaProperty: typeof factory.createMetaProperty;
/** @deprecated Use `factory.updateMetaProperty` or the factory supplied by your transformation context instead. */
const updateMetaProperty: typeof factory.updateMetaProperty;
/** @deprecated Use `factory.createTemplateSpan` or the factory supplied by your transformation context instead. */
const createTemplateSpan: typeof factory.createTemplateSpan;
/** @deprecated Use `factory.updateTemplateSpan` or the factory supplied by your transformation context instead. */
const updateTemplateSpan: typeof factory.updateTemplateSpan;
/** @deprecated Use `factory.createSemicolonClassElement` or the factory supplied by your transformation context instead. */
const createSemicolonClassElement: typeof factory.createSemicolonClassElement;
/** @deprecated Use `factory.createBlock` or the factory supplied by your transformation context instead. */
const createBlock: typeof factory.createBlock;
/** @deprecated Use `factory.updateBlock` or the factory supplied by your transformation context instead. */
const updateBlock: typeof factory.updateBlock;
/** @deprecated Use `factory.createVariableStatement` or the factory supplied by your transformation context instead. */
const createVariableStatement: typeof factory.createVariableStatement;
/** @deprecated Use `factory.updateVariableStatement` or the factory supplied by your transformation context instead. */
const updateVariableStatement: typeof factory.updateVariableStatement;
/** @deprecated Use `factory.createEmptyStatement` or the factory supplied by your transformation context instead. */
const createEmptyStatement: typeof factory.createEmptyStatement;
/** @deprecated Use `factory.createExpressionStatement` or the factory supplied by your transformation context instead. */
const createExpressionStatement: typeof factory.createExpressionStatement;
/** @deprecated Use `factory.updateExpressionStatement` or the factory supplied by your transformation context instead. */
const updateExpressionStatement: typeof factory.updateExpressionStatement;
/** @deprecated Use `factory.createExpressionStatement` or the factory supplied by your transformation context instead. */
const createStatement: typeof factory.createExpressionStatement;
/** @deprecated Use `factory.updateExpressionStatement` or the factory supplied by your transformation context instead. */
const updateStatement: typeof factory.updateExpressionStatement;
/** @deprecated Use `factory.createIfStatement` or the factory supplied by your transformation context instead. */
const createIf: typeof factory.createIfStatement;
/** @deprecated Use `factory.updateIfStatement` or the factory supplied by your transformation context instead. */
const updateIf: typeof factory.updateIfStatement;
/** @deprecated Use `factory.createDoStatement` or the factory supplied by your transformation context instead. */
const createDo: typeof factory.createDoStatement;
/** @deprecated Use `factory.updateDoStatement` or the factory supplied by your transformation context instead. */
const updateDo: typeof factory.updateDoStatement;
/** @deprecated Use `factory.createWhileStatement` or the factory supplied by your transformation context instead. */
const createWhile: typeof factory.createWhileStatement;
/** @deprecated Use `factory.updateWhileStatement` or the factory supplied by your transformation context instead. */
const updateWhile: typeof factory.updateWhileStatement;
/** @deprecated Use `factory.createForStatement` or the factory supplied by your transformation context instead. */
const createFor: typeof factory.createForStatement;
/** @deprecated Use `factory.updateForStatement` or the factory supplied by your transformation context instead. */
const updateFor: typeof factory.updateForStatement;
/** @deprecated Use `factory.createForInStatement` or the factory supplied by your transformation context instead. */
const createForIn: typeof factory.createForInStatement;
/** @deprecated Use `factory.updateForInStatement` or the factory supplied by your transformation context instead. */
const updateForIn: typeof factory.updateForInStatement;
/** @deprecated Use `factory.createForOfStatement` or the factory supplied by your transformation context instead. */
const createForOf: typeof factory.createForOfStatement;
/** @deprecated Use `factory.updateForOfStatement` or the factory supplied by your transformation context instead. */
const updateForOf: typeof factory.updateForOfStatement;
/** @deprecated Use `factory.createContinueStatement` or the factory supplied by your transformation context instead. */
const createContinue: typeof factory.createContinueStatement;
/** @deprecated Use `factory.updateContinueStatement` or the factory supplied by your transformation context instead. */
const updateContinue: typeof factory.updateContinueStatement;
/** @deprecated Use `factory.createBreakStatement` or the factory supplied by your transformation context instead. */
const createBreak: typeof factory.createBreakStatement;
/** @deprecated Use `factory.updateBreakStatement` or the factory supplied by your transformation context instead. */
const updateBreak: typeof factory.updateBreakStatement;
/** @deprecated Use `factory.createReturnStatement` or the factory supplied by your transformation context instead. */
const createReturn: typeof factory.createReturnStatement;
/** @deprecated Use `factory.updateReturnStatement` or the factory supplied by your transformation context instead. */
const updateReturn: typeof factory.updateReturnStatement;
/** @deprecated Use `factory.createWithStatement` or the factory supplied by your transformation context instead. */
const createWith: typeof factory.createWithStatement;
/** @deprecated Use `factory.updateWithStatement` or the factory supplied by your transformation context instead. */
const updateWith: typeof factory.updateWithStatement;
/** @deprecated Use `factory.createSwitchStatement` or the factory supplied by your transformation context instead. */
const createSwitch: typeof factory.createSwitchStatement;
/** @deprecated Use `factory.updateSwitchStatement` or the factory supplied by your transformation context instead. */
const updateSwitch: typeof factory.updateSwitchStatement;
/** @deprecated Use `factory.createLabelStatement` or the factory supplied by your transformation context instead. */
const createLabel: typeof factory.createLabeledStatement;
/** @deprecated Use `factory.updateLabelStatement` or the factory supplied by your transformation context instead. */
const updateLabel: typeof factory.updateLabeledStatement;
/** @deprecated Use `factory.createThrowStatement` or the factory supplied by your transformation context instead. */
const createThrow: typeof factory.createThrowStatement;
/** @deprecated Use `factory.updateThrowStatement` or the factory supplied by your transformation context instead. */
const updateThrow: typeof factory.updateThrowStatement;
/** @deprecated Use `factory.createTryStatement` or the factory supplied by your transformation context instead. */
const createTry: typeof factory.createTryStatement;
/** @deprecated Use `factory.updateTryStatement` or the factory supplied by your transformation context instead. */
const updateTry: typeof factory.updateTryStatement;
/** @deprecated Use `factory.createDebuggerStatement` or the factory supplied by your transformation context instead. */
const createDebuggerStatement: typeof factory.createDebuggerStatement;
/** @deprecated Use `factory.createVariableDeclarationList` or the factory supplied by your transformation context instead. */
const createVariableDeclarationList: typeof factory.createVariableDeclarationList;
/** @deprecated Use `factory.updateVariableDeclarationList` or the factory supplied by your transformation context instead. */
const updateVariableDeclarationList: typeof factory.updateVariableDeclarationList;
/** @deprecated Use `factory.createFunctionDeclaration` or the factory supplied by your transformation context instead. */
const createFunctionDeclaration: typeof factory.createFunctionDeclaration;
/** @deprecated Use `factory.updateFunctionDeclaration` or the factory supplied by your transformation context instead. */
const updateFunctionDeclaration: typeof factory.updateFunctionDeclaration;
/** @deprecated Use `factory.createClassDeclaration` or the factory supplied by your transformation context instead. */
const createClassDeclaration: typeof factory.createClassDeclaration;
/** @deprecated Use `factory.updateClassDeclaration` or the factory supplied by your transformation context instead. */
const updateClassDeclaration: typeof factory.updateClassDeclaration;
/** @deprecated Use `factory.createInterfaceDeclaration` or the factory supplied by your transformation context instead. */
const createInterfaceDeclaration: typeof factory.createInterfaceDeclaration;
/** @deprecated Use `factory.updateInterfaceDeclaration` or the factory supplied by your transformation context instead. */
const updateInterfaceDeclaration: typeof factory.updateInterfaceDeclaration;
/** @deprecated Use `factory.createTypeAliasDeclaration` or the factory supplied by your transformation context instead. */
const createTypeAliasDeclaration: typeof factory.createTypeAliasDeclaration;
/** @deprecated Use `factory.updateTypeAliasDeclaration` or the factory supplied by your transformation context instead. */
const updateTypeAliasDeclaration: typeof factory.updateTypeAliasDeclaration;
/** @deprecated Use `factory.createEnumDeclaration` or the factory supplied by your transformation context instead. */
const createEnumDeclaration: typeof factory.createEnumDeclaration;
/** @deprecated Use `factory.updateEnumDeclaration` or the factory supplied by your transformation context instead. */
const updateEnumDeclaration: typeof factory.updateEnumDeclaration;
/** @deprecated Use `factory.createModuleDeclaration` or the factory supplied by your transformation context instead. */
const createModuleDeclaration: typeof factory.createModuleDeclaration;
/** @deprecated Use `factory.updateModuleDeclaration` or the factory supplied by your transformation context instead. */
const updateModuleDeclaration: typeof factory.updateModuleDeclaration;
/** @deprecated Use `factory.createModuleBlock` or the factory supplied by your transformation context instead. */
const createModuleBlock: typeof factory.createModuleBlock;
/** @deprecated Use `factory.updateModuleBlock` or the factory supplied by your transformation context instead. */
const updateModuleBlock: typeof factory.updateModuleBlock;
/** @deprecated Use `factory.createCaseBlock` or the factory supplied by your transformation context instead. */
const createCaseBlock: typeof factory.createCaseBlock;
/** @deprecated Use `factory.updateCaseBlock` or the factory supplied by your transformation context instead. */
const updateCaseBlock: typeof factory.updateCaseBlock;
/** @deprecated Use `factory.createNamespaceExportDeclaration` or the factory supplied by your transformation context instead. */
const createNamespaceExportDeclaration: typeof factory.createNamespaceExportDeclaration;
/** @deprecated Use `factory.updateNamespaceExportDeclaration` or the factory supplied by your transformation context instead. */
const updateNamespaceExportDeclaration: typeof factory.updateNamespaceExportDeclaration;
/** @deprecated Use `factory.createImportEqualsDeclaration` or the factory supplied by your transformation context instead. */
const createImportEqualsDeclaration: typeof factory.createImportEqualsDeclaration;
/** @deprecated Use `factory.updateImportEqualsDeclaration` or the factory supplied by your transformation context instead. */
const updateImportEqualsDeclaration: typeof factory.updateImportEqualsDeclaration;
/** @deprecated Use `factory.createImportDeclaration` or the factory supplied by your transformation context instead. */
const createImportDeclaration: typeof factory.createImportDeclaration;
/** @deprecated Use `factory.updateImportDeclaration` or the factory supplied by your transformation context instead. */
const updateImportDeclaration: typeof factory.updateImportDeclaration;
/** @deprecated Use `factory.createNamespaceImport` or the factory supplied by your transformation context instead. */
const createNamespaceImport: typeof factory.createNamespaceImport;
/** @deprecated Use `factory.updateNamespaceImport` or the factory supplied by your transformation context instead. */
const updateNamespaceImport: typeof factory.updateNamespaceImport;
/** @deprecated Use `factory.createNamedImports` or the factory supplied by your transformation context instead. */
const createNamedImports: typeof factory.createNamedImports;
/** @deprecated Use `factory.updateNamedImports` or the factory supplied by your transformation context instead. */
const updateNamedImports: typeof factory.updateNamedImports;
/** @deprecated Use `factory.createImportSpecifier` or the factory supplied by your transformation context instead. */
const createImportSpecifier: typeof factory.createImportSpecifier;
/** @deprecated Use `factory.updateImportSpecifier` or the factory supplied by your transformation context instead. */
const updateImportSpecifier: typeof factory.updateImportSpecifier;
/** @deprecated Use `factory.createExportAssignment` or the factory supplied by your transformation context instead. */
const createExportAssignment: typeof factory.createExportAssignment;
/** @deprecated Use `factory.updateExportAssignment` or the factory supplied by your transformation context instead. */
const updateExportAssignment: typeof factory.updateExportAssignment;
/** @deprecated Use `factory.createNamedExports` or the factory supplied by your transformation context instead. */
const createNamedExports: typeof factory.createNamedExports;
/** @deprecated Use `factory.updateNamedExports` or the factory supplied by your transformation context instead. */
const updateNamedExports: typeof factory.updateNamedExports;
/** @deprecated Use `factory.createExportSpecifier` or the factory supplied by your transformation context instead. */
const createExportSpecifier: typeof factory.createExportSpecifier;
/** @deprecated Use `factory.updateExportSpecifier` or the factory supplied by your transformation context instead. */
const updateExportSpecifier: typeof factory.updateExportSpecifier;
/** @deprecated Use `factory.createExternalModuleReference` or the factory supplied by your transformation context instead. */
const createExternalModuleReference: typeof factory.createExternalModuleReference;
/** @deprecated Use `factory.updateExternalModuleReference` or the factory supplied by your transformation context instead. */
const updateExternalModuleReference: typeof factory.updateExternalModuleReference;
/** @deprecated Use `factory.createJSDocTypeExpression` or the factory supplied by your transformation context instead. */
const createJSDocTypeExpression: typeof factory.createJSDocTypeExpression;
/** @deprecated Use `factory.createJSDocTypeTag` or the factory supplied by your transformation context instead. */
const createJSDocTypeTag: typeof factory.createJSDocTypeTag;
/** @deprecated Use `factory.createJSDocReturnTag` or the factory supplied by your transformation context instead. */
const createJSDocReturnTag: typeof factory.createJSDocReturnTag;
/** @deprecated Use `factory.createJSDocThisTag` or the factory supplied by your transformation context instead. */
const createJSDocThisTag: typeof factory.createJSDocThisTag;
/** @deprecated Use `factory.createJSDocComment` or the factory supplied by your transformation context instead. */
const createJSDocComment: typeof factory.createJSDocComment;
/** @deprecated Use `factory.createJSDocParameterTag` or the factory supplied by your transformation context instead. */
const createJSDocParameterTag: typeof factory.createJSDocParameterTag;
/** @deprecated Use `factory.createJSDocClassTag` or the factory supplied by your transformation context instead. */
const createJSDocClassTag: typeof factory.createJSDocClassTag;
/** @deprecated Use `factory.createJSDocAugmentsTag` or the factory supplied by your transformation context instead. */
const createJSDocAugmentsTag: typeof factory.createJSDocAugmentsTag;
/** @deprecated Use `factory.createJSDocEnumTag` or the factory supplied by your transformation context instead. */
const createJSDocEnumTag: typeof factory.createJSDocEnumTag;
/** @deprecated Use `factory.createJSDocTemplateTag` or the factory supplied by your transformation context instead. */
const createJSDocTemplateTag: typeof factory.createJSDocTemplateTag;
/** @deprecated Use `factory.createJSDocTypedefTag` or the factory supplied by your transformation context instead. */
const createJSDocTypedefTag: typeof factory.createJSDocTypedefTag;
/** @deprecated Use `factory.createJSDocCallbackTag` or the factory supplied by your transformation context instead. */
const createJSDocCallbackTag: typeof factory.createJSDocCallbackTag;
/** @deprecated Use `factory.createJSDocSignature` or the factory supplied by your transformation context instead. */
const createJSDocSignature: typeof factory.createJSDocSignature;
/** @deprecated Use `factory.createJSDocPropertyTag` or the factory supplied by your transformation context instead. */
const createJSDocPropertyTag: typeof factory.createJSDocPropertyTag;
/** @deprecated Use `factory.createJSDocTypeLiteral` or the factory supplied by your transformation context instead. */
const createJSDocTypeLiteral: typeof factory.createJSDocTypeLiteral;
/** @deprecated Use `factory.createJSDocImplementsTag` or the factory supplied by your transformation context instead. */
const createJSDocImplementsTag: typeof factory.createJSDocImplementsTag;
/** @deprecated Use `factory.createJSDocAuthorTag` or the factory supplied by your transformation context instead. */
const createJSDocAuthorTag: typeof factory.createJSDocAuthorTag;
/** @deprecated Use `factory.createJSDocPublicTag` or the factory supplied by your transformation context instead. */
const createJSDocPublicTag: typeof factory.createJSDocPublicTag;
/** @deprecated Use `factory.createJSDocPrivateTag` or the factory supplied by your transformation context instead. */
const createJSDocPrivateTag: typeof factory.createJSDocPrivateTag;
/** @deprecated Use `factory.createJSDocProtectedTag` or the factory supplied by your transformation context instead. */
const createJSDocProtectedTag: typeof factory.createJSDocProtectedTag;
/** @deprecated Use `factory.createJSDocReadonlyTag` or the factory supplied by your transformation context instead. */
const createJSDocReadonlyTag: typeof factory.createJSDocReadonlyTag;
/** @deprecated Use `factory.createJSDocUnknownTag` or the factory supplied by your transformation context instead. */
const createJSDocTag: typeof factory.createJSDocUnknownTag;
/** @deprecated Use `factory.createJsxElement` or the factory supplied by your transformation context instead. */
const createJsxElement: typeof factory.createJsxElement;
/** @deprecated Use `factory.updateJsxElement` or the factory supplied by your transformation context instead. */
const updateJsxElement: typeof factory.updateJsxElement;
/** @deprecated Use `factory.createJsxSelfClosingElement` or the factory supplied by your transformation context instead. */
const createJsxSelfClosingElement: typeof factory.createJsxSelfClosingElement;
/** @deprecated Use `factory.updateJsxSelfClosingElement` or the factory supplied by your transformation context instead. */
const updateJsxSelfClosingElement: typeof factory.updateJsxSelfClosingElement;
/** @deprecated Use `factory.createJsxOpeningElement` or the factory supplied by your transformation context instead. */
const createJsxOpeningElement: typeof factory.createJsxOpeningElement;
/** @deprecated Use `factory.updateJsxOpeningElement` or the factory supplied by your transformation context instead. */
const updateJsxOpeningElement: typeof factory.updateJsxOpeningElement;
/** @deprecated Use `factory.createJsxClosingElement` or the factory supplied by your transformation context instead. */
const createJsxClosingElement: typeof factory.createJsxClosingElement;
/** @deprecated Use `factory.updateJsxClosingElement` or the factory supplied by your transformation context instead. */
const updateJsxClosingElement: typeof factory.updateJsxClosingElement;
/** @deprecated Use `factory.createJsxFragment` or the factory supplied by your transformation context instead. */
const createJsxFragment: typeof factory.createJsxFragment;
/** @deprecated Use `factory.createJsxText` or the factory supplied by your transformation context instead. */
const createJsxText: typeof factory.createJsxText;
/** @deprecated Use `factory.updateJsxText` or the factory supplied by your transformation context instead. */
const updateJsxText: typeof factory.updateJsxText;
/** @deprecated Use `factory.createJsxOpeningFragment` or the factory supplied by your transformation context instead. */
const createJsxOpeningFragment: typeof factory.createJsxOpeningFragment;
/** @deprecated Use `factory.createJsxJsxClosingFragment` or the factory supplied by your transformation context instead. */
const createJsxJsxClosingFragment: typeof factory.createJsxJsxClosingFragment;
/** @deprecated Use `factory.updateJsxFragment` or the factory supplied by your transformation context instead. */
const updateJsxFragment: typeof factory.updateJsxFragment;
/** @deprecated Use `factory.createJsxAttribute` or the factory supplied by your transformation context instead. */
const createJsxAttribute: typeof factory.createJsxAttribute;
/** @deprecated Use `factory.updateJsxAttribute` or the factory supplied by your transformation context instead. */
const updateJsxAttribute: typeof factory.updateJsxAttribute;
/** @deprecated Use `factory.createJsxAttributes` or the factory supplied by your transformation context instead. */
const createJsxAttributes: typeof factory.createJsxAttributes;
/** @deprecated Use `factory.updateJsxAttributes` or the factory supplied by your transformation context instead. */
const updateJsxAttributes: typeof factory.updateJsxAttributes;
/** @deprecated Use `factory.createJsxSpreadAttribute` or the factory supplied by your transformation context instead. */
const createJsxSpreadAttribute: typeof factory.createJsxSpreadAttribute;
/** @deprecated Use `factory.updateJsxSpreadAttribute` or the factory supplied by your transformation context instead. */
const updateJsxSpreadAttribute: typeof factory.updateJsxSpreadAttribute;
/** @deprecated Use `factory.createJsxExpression` or the factory supplied by your transformation context instead. */
const createJsxExpression: typeof factory.createJsxExpression;
/** @deprecated Use `factory.updateJsxExpression` or the factory supplied by your transformation context instead. */
const updateJsxExpression: typeof factory.updateJsxExpression;
/** @deprecated Use `factory.createCaseClause` or the factory supplied by your transformation context instead. */
const createCaseClause: typeof factory.createCaseClause;
/** @deprecated Use `factory.updateCaseClause` or the factory supplied by your transformation context instead. */
const updateCaseClause: typeof factory.updateCaseClause;
/** @deprecated Use `factory.createDefaultClause` or the factory supplied by your transformation context instead. */
const createDefaultClause: typeof factory.createDefaultClause;
/** @deprecated Use `factory.updateDefaultClause` or the factory supplied by your transformation context instead. */
const updateDefaultClause: typeof factory.updateDefaultClause;
/** @deprecated Use `factory.createHeritageClause` or the factory supplied by your transformation context instead. */
const createHeritageClause: typeof factory.createHeritageClause;
/** @deprecated Use `factory.updateHeritageClause` or the factory supplied by your transformation context instead. */
const updateHeritageClause: typeof factory.updateHeritageClause;
/** @deprecated Use `factory.createCatchClause` or the factory supplied by your transformation context instead. */
const createCatchClause: typeof factory.createCatchClause;
/** @deprecated Use `factory.updateCatchClause` or the factory supplied by your transformation context instead. */
const updateCatchClause: typeof factory.updateCatchClause;
/** @deprecated Use `factory.createPropertyAssignment` or the factory supplied by your transformation context instead. */
const createPropertyAssignment: typeof factory.createPropertyAssignment;
/** @deprecated Use `factory.updatePropertyAssignment` or the factory supplied by your transformation context instead. */
const updatePropertyAssignment: typeof factory.updatePropertyAssignment;
/** @deprecated Use `factory.createShorthandPropertyAssignment` or the factory supplied by your transformation context instead. */
const createShorthandPropertyAssignment: typeof factory.createShorthandPropertyAssignment;
/** @deprecated Use `factory.updateShorthandPropertyAssignment` or the factory supplied by your transformation context instead. */
const updateShorthandPropertyAssignment: typeof factory.updateShorthandPropertyAssignment;
/** @deprecated Use `factory.createSpreadAssignment` or the factory supplied by your transformation context instead. */
const createSpreadAssignment: typeof factory.createSpreadAssignment;
/** @deprecated Use `factory.updateSpreadAssignment` or the factory supplied by your transformation context instead. */
const updateSpreadAssignment: typeof factory.updateSpreadAssignment;
/** @deprecated Use `factory.createEnumMember` or the factory supplied by your transformation context instead. */
const createEnumMember: typeof factory.createEnumMember;
/** @deprecated Use `factory.updateEnumMember` or the factory supplied by your transformation context instead. */
const updateEnumMember: typeof factory.updateEnumMember;
/** @deprecated Use `factory.updateSourceFile` or the factory supplied by your transformation context instead. */
const updateSourceFileNode: typeof factory.updateSourceFile;
/** @deprecated Use `factory.createNotEmittedStatement` or the factory supplied by your transformation context instead. */
const createNotEmittedStatement: typeof factory.createNotEmittedStatement;
/** @deprecated Use `factory.createPartiallyEmittedExpression` or the factory supplied by your transformation context instead. */
const createPartiallyEmittedExpression: typeof factory.createPartiallyEmittedExpression;
/** @deprecated Use `factory.updatePartiallyEmittedExpression` or the factory supplied by your transformation context instead. */
const updatePartiallyEmittedExpression: typeof factory.updatePartiallyEmittedExpression;
/** @deprecated Use `factory.createCommaListExpression` or the factory supplied by your transformation context instead. */
const createCommaList: typeof factory.createCommaListExpression;
/** @deprecated Use `factory.updateCommaListExpression` or the factory supplied by your transformation context instead. */
const updateCommaList: typeof factory.updateCommaListExpression;
/** @deprecated Use `factory.createBundle` or the factory supplied by your transformation context instead. */
const createBundle: typeof factory.createBundle;
/** @deprecated Use `factory.updateBundle` or the factory supplied by your transformation context instead. */
const updateBundle: typeof factory.updateBundle;
/** @deprecated Use `factory.createImmediatelyInvokedFunctionExpression` or the factory supplied by your transformation context instead. */
const createImmediatelyInvokedFunctionExpression: typeof factory.createImmediatelyInvokedFunctionExpression;
/** @deprecated Use `factory.createImmediatelyInvokedArrowFunction` or the factory supplied by your transformation context instead. */
const createImmediatelyInvokedArrowFunction: typeof factory.createImmediatelyInvokedArrowFunction;
/** @deprecated Use `factory.createVoidZero` or the factory supplied by your transformation context instead. */
const createVoidZero: typeof factory.createVoidZero;
/** @deprecated Use `factory.createExportDefault` or the factory supplied by your transformation context instead. */
const createExportDefault: typeof factory.createExportDefault;
/** @deprecated Use `factory.createExternalModuleExport` or the factory supplied by your transformation context instead. */
const createExternalModuleExport: typeof factory.createExternalModuleExport;
/** @deprecated Use `factory.createNamespaceExport` or the factory supplied by your transformation context instead. */
const createNamespaceExport: typeof factory.createNamespaceExport;
/** @deprecated Use `factory.updateNamespaceExport` or the factory supplied by your transformation context instead. */
const updateNamespaceExport: typeof factory.updateNamespaceExport;
/** @deprecated Use `factory.createToken` or the factory supplied by your transformation context instead. */
const createToken: <TKind extends SyntaxKind>(kind: TKind) => Token<TKind>;
/** @deprecated Use `factory.createIdentifier` or the factory supplied by your transformation context instead. */
const createIdentifier: (text: string) => Identifier;
/** @deprecated Use `factory.createTempVariable` or the factory supplied by your transformation context instead. */
const createTempVariable: (recordTempVariable: ((node: Identifier) => void) | undefined) => Identifier;
/** @deprecated Use `factory.getGeneratedNameForNode` or the factory supplied by your transformation context instead. */
const getGeneratedNameForNode: (node: Node | undefined) => Identifier;
/** @deprecated Use `factory.createUniqueName(text, GeneratedIdentifierFlags.Optimistic)` or the factory supplied by your transformation context instead. */
const createOptimisticUniqueName: (text: string) => Identifier;
/** @deprecated Use `factory.createUniqueName(text, GeneratedIdentifierFlags.Optimistic | GeneratedIdentifierFlags.FileLevel)` or the factory supplied by your transformation context instead. */
const createFileLevelUniqueName: (text: string) => Identifier;
/** @deprecated Use `factory.createIndexSignature` or the factory supplied by your transformation context instead. */
const createIndexSignature: (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode) => IndexSignatureDeclaration;
/** @deprecated Use `factory.createTypePredicateNode` or the factory supplied by your transformation context instead. */
const createTypePredicateNode: (parameterName: Identifier | ThisTypeNode | string, type: TypeNode) => TypePredicateNode;
/** @deprecated Use `factory.updateTypePredicateNode` or the factory supplied by your transformation context instead. */
const updateTypePredicateNode: (node: TypePredicateNode, parameterName: Identifier | ThisTypeNode, type: TypeNode) => TypePredicateNode;
/** @deprecated Use `factory.createStringLiteral`, `factory.createStringLiteralFromNode`, `factory.createNumericLiteral`, `factory.createBigIntLiteral`, `factory.createTrue`, `factory.createFalse`, or the factory supplied by your transformation context instead. */
const createLiteral: {
(value: string | StringLiteral | NoSubstitutionTemplateLiteral | NumericLiteral | Identifier): StringLiteral;
(value: number | PseudoBigInt): NumericLiteral;
(value: boolean): BooleanLiteral;
(value: string | number | PseudoBigInt | boolean): PrimaryExpression;
};
/** @deprecated Use `factory.createMethodSignature` or the factory supplied by your transformation context instead. */
const createMethodSignature: (typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, name: string | PropertyName, questionToken: QuestionToken | undefined) => MethodSignature;
/** @deprecated Use `factory.updateMethodSignature` or the factory supplied by your transformation context instead. */
const updateMethodSignature: (node: MethodSignature, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode | undefined, name: PropertyName, questionToken: QuestionToken | undefined) => MethodSignature;
/** @deprecated Use `factory.createTypeOperatorNode` or the factory supplied by your transformation context instead. */
const createTypeOperatorNode: {
(type: TypeNode): TypeOperatorNode;
(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword, type: TypeNode): TypeOperatorNode;
};
/** @deprecated Use `factory.createTaggedTemplate` or the factory supplied by your transformation context instead. */
const createTaggedTemplate: {
(tag: Expression, template: TemplateLiteral): TaggedTemplateExpression;
(tag: Expression, typeArguments: readonly TypeNode[] | undefined, template: TemplateLiteral): TaggedTemplateExpression;
};
/** @deprecated Use `factory.updateTaggedTemplate` or the factory supplied by your transformation context instead. */
const updateTaggedTemplate: {
(node: TaggedTemplateExpression, tag: Expression, template: TemplateLiteral): TaggedTemplateExpression;
(node: TaggedTemplateExpression, tag: Expression, typeArguments: readonly TypeNode[] | undefined, template: TemplateLiteral): TaggedTemplateExpression;
};
/** @deprecated Use `factory.updateBinary` or the factory supplied by your transformation context instead. */
const updateBinary: (node: BinaryExpression, left: Expression, right: Expression, operator?: BinaryOperator | BinaryOperatorToken) => BinaryExpression;
/** @deprecated Use `factory.createConditional` or the factory supplied by your transformation context instead. */
const createConditional: {
(condition: Expression, whenTrue: Expression, whenFalse: Expression): ConditionalExpression;
(condition: Expression, questionToken: QuestionToken, whenTrue: Expression, colonToken: ColonToken, whenFalse: Expression): ConditionalExpression;
};
/** @deprecated Use `factory.createYield` or the factory supplied by your transformation context instead. */
const createYield: {
(expression?: Expression | undefined): YieldExpression;
(asteriskToken: AsteriskToken | undefined, expression: Expression): YieldExpression;
};
/** @deprecated Use `factory.createClassExpression` or the factory supplied by your transformation context instead. */
const createClassExpression: (modifiers: readonly Modifier[] | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]) => ClassExpression;
/** @deprecated Use `factory.updateClassExpression` or the factory supplied by your transformation context instead. */
const updateClassExpression: (node: ClassExpression, modifiers: readonly Modifier[] | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]) => ClassExpression;
/** @deprecated Use `factory.createPropertySignature` or the factory supplied by your transformation context instead. */
const createPropertySignature: (modifiers: readonly Modifier[] | undefined, name: PropertyName | string, questionToken: QuestionToken | undefined, type: TypeNode | undefined, initializer?: Expression | undefined) => PropertySignature;
/** @deprecated Use `factory.updatePropertySignature` or the factory supplied by your transformation context instead. */
const updatePropertySignature: (node: PropertySignature, modifiers: readonly Modifier[] | undefined, name: PropertyName, questionToken: QuestionToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined) => PropertySignature;
/** @deprecated Use `factory.createExpressionWithTypeArguments` or the factory supplied by your transformation context instead. */
const createExpressionWithTypeArguments: (typeArguments: readonly TypeNode[] | undefined, expression: Expression) => ExpressionWithTypeArguments;
/** @deprecated Use `factory.updateExpressionWithTypeArguments` or the factory supplied by your transformation context instead. */
const updateExpressionWithTypeArguments: (node: ExpressionWithTypeArguments, typeArguments: readonly TypeNode[] | undefined, expression: Expression) => ExpressionWithTypeArguments;
/** @deprecated Use `factory.createArrowFunction` or the factory supplied by your transformation context instead. */
const createArrowFunction: {
(modifiers: readonly Modifier[] | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, equalsGreaterThanToken: EqualsGreaterThanToken | undefined, body: ConciseBody): ArrowFunction;
(modifiers: readonly Modifier[] | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: ConciseBody): ArrowFunction;
};
/** @deprecated Use `factory.updateArrowFunction` or the factory supplied by your transformation context instead. */
const updateArrowFunction: {
(node: ArrowFunction, modifiers: readonly Modifier[] | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, equalsGreaterThanToken: EqualsGreaterThanToken, body: ConciseBody): ArrowFunction;
(node: ArrowFunction, modifiers: readonly Modifier[] | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: ConciseBody): ArrowFunction;
};
/** @deprecated Use `factory.createVariableDeclaration` or the factory supplied by your transformation context instead. */
const createVariableDeclaration: {
(name: string | BindingName, type?: TypeNode | undefined, initializer?: Expression | undefined): VariableDeclaration;
(name: string | BindingName, exclamationToken: ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): VariableDeclaration;
};
/** @deprecated Use `factory.updateVariableDeclaration` or the factory supplied by your transformation context instead. */
const updateVariableDeclaration: {
(node: VariableDeclaration, name: BindingName, type: TypeNode | undefined, initializer: Expression | undefined): VariableDeclaration;
(node: VariableDeclaration, name: BindingName, exclamationToken: ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): VariableDeclaration;
};
/** @deprecated Use `factory.createImportClause` or the factory supplied by your transformation context instead. */
const createImportClause: (name: Identifier | undefined, namedBindings: NamedImportBindings | undefined, isTypeOnly?: any) => ImportClause;
/** @deprecated Use `factory.updateImportClause` or the factory supplied by your transformation context instead. */
const updateImportClause: (node: ImportClause, name: Identifier | undefined, namedBindings: NamedImportBindings | undefined, isTypeOnly: boolean) => ImportClause;
/** @deprecated Use `factory.createExportDeclaration` or the factory supplied by your transformation context instead. */
const createExportDeclaration: (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, exportClause: NamedExportBindings | undefined, moduleSpecifier?: Expression | undefined, isTypeOnly?: any) => ExportDeclaration;
/** @deprecated Use `factory.updateExportDeclaration` or the factory supplied by your transformation context instead. */
const updateExportDeclaration: (node: ExportDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, exportClause: NamedExportBindings | undefined, moduleSpecifier: Expression | undefined, isTypeOnly: boolean) => ExportDeclaration;
/** @deprecated Use `factory.createJSDocParameterTag` or the factory supplied by your transformation context instead. */
const createJSDocParamTag: (name: EntityName, isBracketed: boolean, typeExpression?: JSDocTypeExpression | undefined, comment?: string | undefined) => JSDocParameterTag;
/** @deprecated Use `factory.createComma` or the factory supplied by your transformation context instead. */
const createComma: (left: Expression, right: Expression) => Expression;
/** @deprecated Use `factory.createLessThan` or the factory supplied by your transformation context instead. */
const createLessThan: (left: Expression, right: Expression) => Expression;
/** @deprecated Use `factory.createAssignment` or the factory supplied by your transformation context instead. */
const createAssignment: (left: Expression, right: Expression) => BinaryExpression;
/** @deprecated Use `factory.createStrictEquality` or the factory supplied by your transformation context instead. */
const createStrictEquality: (left: Expression, right: Expression) => BinaryExpression;
/** @deprecated Use `factory.createStrictInequality` or the factory supplied by your transformation context instead. */
const createStrictInequality: (left: Expression, right: Expression) => BinaryExpression;
/** @deprecated Use `factory.createAdd` or the factory supplied by your transformation context instead. */
const createAdd: (left: Expression, right: Expression) => BinaryExpression;
/** @deprecated Use `factory.createSubtract` or the factory supplied by your transformation context instead. */
const createSubtract: (left: Expression, right: Expression) => BinaryExpression;
/** @deprecated Use `factory.createLogicalAnd` or the factory supplied by your transformation context instead. */
const createLogicalAnd: (left: Expression, right: Expression) => BinaryExpression;
/** @deprecated Use `factory.createLogicalOr` or the factory supplied by your transformation context instead. */
const createLogicalOr: (left: Expression, right: Expression) => BinaryExpression;
/** @deprecated Use `factory.createPostfixIncrement` or the factory supplied by your transformation context instead. */
const createPostfixIncrement: (operand: Expression) => PostfixUnaryExpression;
/** @deprecated Use `factory.createLogicalNot` or the factory supplied by your transformation context instead. */
const createLogicalNot: (operand: Expression) => PrefixUnaryExpression;
/** @deprecated Use an appropriate `factory` method instead. */
const createNode: (kind: SyntaxKind, pos?: any, end?: any) => Node;
/**
* Creates a shallow, memberwise clone of a node ~for mutation~ with its `pos`, `end`, and `parent` set.
*
* NOTE: It is unsafe to change any properties of a `Node` that relate to its AST children, as those changes won't be
* captured with respect to transformations.
*
* @deprecated Use an appropriate `factory.update...` method instead, use `setCommentRange` or `setSourceMapRange`, and avoid setting `parent`.
*/
const getMutableClone: <T extends Node>(node: T) => T;
/** @deprecated Use `isTypeAssertionExpression` instead. */
const isTypeAssertion: (node: Node) => node is TypeAssertion;
/**
* @deprecated Use `isMemberName` instead.
*/
const isIdentifierOrPrivateIdentifier: (node: Node) => node is MemberName;
}
export = ts;

952
tests/baselines/reference/api/typescript.d.ts vendored
View File

@ -541,30 +541,6 @@ declare namespace ts {
getLastToken(sourceFile?: SourceFile): Node | undefined;
forEachChild<T>(cbNode: (node: Node) => T | undefined, cbNodeArray?: (nodes: NodeArray<Node>) => T | undefined): T | undefined;
}
interface Node {
/**
* @deprecated `decorators` has been removed from `Node` and merged with `modifiers` on the `Node` subtypes that support them.
* Use `ts.canHaveDecorators()` to test whether a `Node` can have decorators.
* Use `ts.getDecorators()` to get the decorators of a `Node`.
*
* For example:
* ```ts
* const decorators = ts.canHaveDecorators(node) ? ts.getDecorators(node) : undefined;
* ```
*/
readonly decorators?: undefined;
/**
* @deprecated `modifiers` has been removed from `Node` and moved to the `Node` subtypes that support them.
* Use `ts.canHaveModifiers()` to test whether a `Node` can have modifiers.
* Use `ts.getModifiers()` to get the modifiers of a `Node`.
*
* For example:
* ```ts
* const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined;
* ```
*/
readonly modifiers?: NodeArray<ModifierLike> | undefined;
}
interface JSDocContainer extends Node {
_jsdocContainerBrand: any;
}
@ -765,10 +741,6 @@ declare namespace ts {
readonly questionToken?: QuestionToken;
readonly type?: TypeNode;
}
interface PropertySignature {
/** @deprecated A property signature cannot have an initializer */
readonly initializer?: Expression | undefined;
}
interface PropertyDeclaration extends ClassElement, JSDocContainer {
readonly kind: SyntaxKind.PropertyDeclaration;
readonly parent: ClassLikeDeclaration;
@ -794,12 +766,6 @@ declare namespace ts {
readonly name: PropertyName;
readonly initializer: Expression;
}
interface PropertyAssignment {
/** @deprecated A property assignment cannot have a question token */
readonly questionToken?: QuestionToken | undefined;
/** @deprecated A property assignment cannot have an exclamation token */
readonly exclamationToken?: ExclamationToken | undefined;
}
interface ShorthandPropertyAssignment extends ObjectLiteralElement, JSDocContainer {
readonly kind: SyntaxKind.ShorthandPropertyAssignment;
readonly parent: ObjectLiteralExpression;
@ -807,14 +773,6 @@ declare namespace ts {
readonly equalsToken?: EqualsToken;
readonly objectAssignmentInitializer?: Expression;
}
interface ShorthandPropertyAssignment {
/** @deprecated A shorthand property assignment cannot have modifiers */
readonly modifiers?: NodeArray<ModifierLike> | undefined;
/** @deprecated A shorthand property assignment cannot have a question token */
readonly questionToken?: QuestionToken | undefined;
/** @deprecated A shorthand property assignment cannot have an exclamation token */
readonly exclamationToken?: ExclamationToken | undefined;
}
interface SpreadAssignment extends ObjectLiteralElement, JSDocContainer {
readonly kind: SyntaxKind.SpreadAssignment;
readonly parent: ObjectLiteralExpression;
@ -937,10 +895,6 @@ declare namespace ts {
interface FunctionTypeNode extends FunctionOrConstructorTypeNodeBase, LocalsContainer {
readonly kind: SyntaxKind.FunctionType;
}
interface FunctionTypeNode {
/** @deprecated A function type cannot have modifiers */
readonly modifiers?: NodeArray<Modifier> | undefined;
}
interface ConstructorTypeNode extends FunctionOrConstructorTypeNodeBase, LocalsContainer {
readonly kind: SyntaxKind.ConstructorType;
readonly modifiers?: NodeArray<Modifier>;
@ -3992,179 +3946,6 @@ declare namespace ts {
createExternalModuleExport(exportName: Identifier): ExportDeclaration;
restoreOuterExpressions(outerExpression: Expression | undefined, innerExpression: Expression, kinds?: OuterExpressionKinds): Expression;
}
interface NodeFactory {
/** @deprecated Use the overload that accepts 'modifiers' */
createConstructorTypeNode(typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): ConstructorTypeNode;
/** @deprecated Use the overload that accepts 'modifiers' */
updateConstructorTypeNode(node: ConstructorTypeNode, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode): ConstructorTypeNode;
}
interface NodeFactory {
createImportTypeNode(argument: TypeNode, assertions?: ImportTypeAssertionContainer, qualifier?: EntityName, typeArguments?: readonly TypeNode[], isTypeOf?: boolean): ImportTypeNode;
/** @deprecated Use the overload that accepts 'assertions' */
createImportTypeNode(argument: TypeNode, qualifier?: EntityName, typeArguments?: readonly TypeNode[], isTypeOf?: boolean): ImportTypeNode;
/** @deprecated Use the overload that accepts 'assertions' */
updateImportTypeNode(node: ImportTypeNode, argument: TypeNode, qualifier: EntityName | undefined, typeArguments: readonly TypeNode[] | undefined, isTypeOf?: boolean): ImportTypeNode;
}
interface NodeFactory {
/** @deprecated Use the overload that accepts 'modifiers' */
createTypeParameterDeclaration(name: string | Identifier, constraint?: TypeNode, defaultType?: TypeNode): TypeParameterDeclaration;
/** @deprecated Use the overload that accepts 'modifiers' */
updateTypeParameterDeclaration(node: TypeParameterDeclaration, name: Identifier, constraint: TypeNode | undefined, defaultType: TypeNode | undefined): TypeParameterDeclaration;
}
interface NodeFactory {
/**
* @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
*/
createParameterDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | BindingName, questionToken?: QuestionToken, type?: TypeNode, initializer?: Expression): ParameterDeclaration;
/**
* @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
*/
updateParameterDeclaration(node: ParameterDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | BindingName, questionToken: QuestionToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): ParameterDeclaration;
/**
* @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
*/
createPropertyDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | PropertyName, questionOrExclamationToken: QuestionToken | ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): PropertyDeclaration;
/**
* @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
*/
updatePropertyDeclaration(node: PropertyDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | PropertyName, questionOrExclamationToken: QuestionToken | ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): PropertyDeclaration;
/**
* @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
*/
createMethodDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: string | PropertyName, questionToken: QuestionToken | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): MethodDeclaration;
/**
* @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
*/
updateMethodDeclaration(node: MethodDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: PropertyName, questionToken: QuestionToken | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): MethodDeclaration;
/**
* @deprecated This node does not support Decorators. Callers should use an overload that does not accept a `decorators` parameter.
*/
createConstructorDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], body: Block | undefined): ConstructorDeclaration;
/**
* @deprecated This node does not support Decorators. Callers should use an overload that does not accept a `decorators` parameter.
*/
updateConstructorDeclaration(node: ConstructorDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], body: Block | undefined): ConstructorDeclaration;
/**
* @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
*/
createGetAccessorDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | PropertyName, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): GetAccessorDeclaration;
/**
* @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
*/
updateGetAccessorDeclaration(node: GetAccessorDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: PropertyName, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): GetAccessorDeclaration;
/**
* @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
*/
createSetAccessorDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | PropertyName, parameters: readonly ParameterDeclaration[], body: Block | undefined): SetAccessorDeclaration;
/**
* @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
*/
updateSetAccessorDeclaration(node: SetAccessorDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: PropertyName, parameters: readonly ParameterDeclaration[], body: Block | undefined): SetAccessorDeclaration;
/**
* @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
*/
createIndexSignature(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): IndexSignatureDeclaration;
/**
* @deprecated Decorators and modifiers are no longer supported for this function. Callers should use an overload that does not accept the `decorators` and `modifiers` parameters.
*/
updateIndexSignature(node: IndexSignatureDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): IndexSignatureDeclaration;
/**
* @deprecated Decorators and modifiers are no longer supported for this function. Callers should use an overload that does not accept the `decorators` and `modifiers` parameters.
*/
createClassStaticBlockDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, body: Block): ClassStaticBlockDeclaration;
/**
* @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
*/
updateClassStaticBlockDeclaration(node: ClassStaticBlockDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, body: Block): ClassStaticBlockDeclaration;
/**
* @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
*/
createClassExpression(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassExpression;
/**
* @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
*/
updateClassExpression(node: ClassExpression, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassExpression;
/**
* @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
*/
createFunctionDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): FunctionDeclaration;
/**
* @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
*/
updateFunctionDeclaration(node: FunctionDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): FunctionDeclaration;
/**
* @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
*/
createClassDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassDeclaration;
/**
* @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
*/
updateClassDeclaration(node: ClassDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassDeclaration;
/**
* @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
*/
createInterfaceDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly TypeElement[]): InterfaceDeclaration;
/**
* @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
*/
updateInterfaceDeclaration(node: InterfaceDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly TypeElement[]): InterfaceDeclaration;
/**
* @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
*/
createTypeAliasDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, type: TypeNode): TypeAliasDeclaration;
/**
* @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
*/
updateTypeAliasDeclaration(node: TypeAliasDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, type: TypeNode): TypeAliasDeclaration;
/**
* @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
*/
createEnumDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, members: readonly EnumMember[]): EnumDeclaration;
/**
* @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
*/
updateEnumDeclaration(node: EnumDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, members: readonly EnumMember[]): EnumDeclaration;
/**
* @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
*/
createModuleDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: ModuleName, body: ModuleBody | undefined, flags?: NodeFlags): ModuleDeclaration;
/**
* @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
*/
updateModuleDeclaration(node: ModuleDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: ModuleName, body: ModuleBody | undefined): ModuleDeclaration;
/**
* @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
*/
createImportEqualsDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, name: string | Identifier, moduleReference: ModuleReference): ImportEqualsDeclaration;
/**
* @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
*/
updateImportEqualsDeclaration(node: ImportEqualsDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, name: Identifier, moduleReference: ModuleReference): ImportEqualsDeclaration;
/**
* @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
*/
createImportDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause?: AssertClause): ImportDeclaration;
/**
* @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
*/
updateImportDeclaration(node: ImportDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration;
/**
* @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
*/
createExportAssignment(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isExportEquals: boolean | undefined, expression: Expression): ExportAssignment;
/**
* @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
*/
updateExportAssignment(node: ExportAssignment, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, expression: Expression): ExportAssignment;
/**
* @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
*/
createExportDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, exportClause: NamedExportBindings | undefined, moduleSpecifier?: Expression, assertClause?: AssertClause): ExportDeclaration;
/**
* @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
*/
updateExportDeclaration(node: ExportDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, exportClause: NamedExportBindings | undefined, moduleSpecifier: Expression | undefined, assertClause: AssertClause | undefined): ExportDeclaration;
}
interface CoreTransformationContext {
readonly factory: NodeFactory;
/** Gets the compiler options supplied to the transformer. */
@ -7299,738 +7080,5 @@ declare namespace ts {
* @param compilerOptions Optional compiler options.
*/
function transform<T extends Node>(source: T | T[], transformers: TransformerFactory<T>[], compilerOptions?: CompilerOptions): TransformationResult<T>;
/** @deprecated Use `factory.createNodeArray` or the factory supplied by your transformation context instead. */
const createNodeArray: typeof factory.createNodeArray;
/** @deprecated Use `factory.createNumericLiteral` or the factory supplied by your transformation context instead. */
const createNumericLiteral: typeof factory.createNumericLiteral;
/** @deprecated Use `factory.createBigIntLiteral` or the factory supplied by your transformation context instead. */
const createBigIntLiteral: typeof factory.createBigIntLiteral;
/** @deprecated Use `factory.createStringLiteral` or the factory supplied by your transformation context instead. */
const createStringLiteral: typeof factory.createStringLiteral;
/** @deprecated Use `factory.createStringLiteralFromNode` or the factory supplied by your transformation context instead. */
const createStringLiteralFromNode: typeof factory.createStringLiteralFromNode;
/** @deprecated Use `factory.createRegularExpressionLiteral` or the factory supplied by your transformation context instead. */
const createRegularExpressionLiteral: typeof factory.createRegularExpressionLiteral;
/** @deprecated Use `factory.createLoopVariable` or the factory supplied by your transformation context instead. */
const createLoopVariable: typeof factory.createLoopVariable;
/** @deprecated Use `factory.createUniqueName` or the factory supplied by your transformation context instead. */
const createUniqueName: typeof factory.createUniqueName;
/** @deprecated Use `factory.createPrivateIdentifier` or the factory supplied by your transformation context instead. */
const createPrivateIdentifier: typeof factory.createPrivateIdentifier;
/** @deprecated Use `factory.createSuper` or the factory supplied by your transformation context instead. */
const createSuper: typeof factory.createSuper;
/** @deprecated Use `factory.createThis` or the factory supplied by your transformation context instead. */
const createThis: typeof factory.createThis;
/** @deprecated Use `factory.createNull` or the factory supplied by your transformation context instead. */
const createNull: typeof factory.createNull;
/** @deprecated Use `factory.createTrue` or the factory supplied by your transformation context instead. */
const createTrue: typeof factory.createTrue;
/** @deprecated Use `factory.createFalse` or the factory supplied by your transformation context instead. */
const createFalse: typeof factory.createFalse;
/** @deprecated Use `factory.createModifier` or the factory supplied by your transformation context instead. */
const createModifier: typeof factory.createModifier;
/** @deprecated Use `factory.createModifiersFromModifierFlags` or the factory supplied by your transformation context instead. */
const createModifiersFromModifierFlags: typeof factory.createModifiersFromModifierFlags;
/** @deprecated Use `factory.createQualifiedName` or the factory supplied by your transformation context instead. */
const createQualifiedName: typeof factory.createQualifiedName;
/** @deprecated Use `factory.updateQualifiedName` or the factory supplied by your transformation context instead. */
const updateQualifiedName: typeof factory.updateQualifiedName;
/** @deprecated Use `factory.createComputedPropertyName` or the factory supplied by your transformation context instead. */
const createComputedPropertyName: typeof factory.createComputedPropertyName;
/** @deprecated Use `factory.updateComputedPropertyName` or the factory supplied by your transformation context instead. */
const updateComputedPropertyName: typeof factory.updateComputedPropertyName;
/** @deprecated Use `factory.createTypeParameterDeclaration` or the factory supplied by your transformation context instead. */
const createTypeParameterDeclaration: typeof factory.createTypeParameterDeclaration;
/** @deprecated Use `factory.updateTypeParameterDeclaration` or the factory supplied by your transformation context instead. */
const updateTypeParameterDeclaration: typeof factory.updateTypeParameterDeclaration;
/** @deprecated Use `factory.createParameterDeclaration` or the factory supplied by your transformation context instead. */
const createParameter: typeof factory.createParameterDeclaration;
/** @deprecated Use `factory.updateParameterDeclaration` or the factory supplied by your transformation context instead. */
const updateParameter: typeof factory.updateParameterDeclaration;
/** @deprecated Use `factory.createDecorator` or the factory supplied by your transformation context instead. */
const createDecorator: typeof factory.createDecorator;
/** @deprecated Use `factory.updateDecorator` or the factory supplied by your transformation context instead. */
const updateDecorator: typeof factory.updateDecorator;
/** @deprecated Use `factory.createPropertyDeclaration` or the factory supplied by your transformation context instead. */
const createProperty: typeof factory.createPropertyDeclaration;
/** @deprecated Use `factory.updatePropertyDeclaration` or the factory supplied by your transformation context instead. */
const updateProperty: typeof factory.updatePropertyDeclaration;
/** @deprecated Use `factory.createMethodDeclaration` or the factory supplied by your transformation context instead. */
const createMethod: typeof factory.createMethodDeclaration;
/** @deprecated Use `factory.updateMethodDeclaration` or the factory supplied by your transformation context instead. */
const updateMethod: typeof factory.updateMethodDeclaration;
/** @deprecated Use `factory.createConstructorDeclaration` or the factory supplied by your transformation context instead. */
const createConstructor: typeof factory.createConstructorDeclaration;
/** @deprecated Use `factory.updateConstructorDeclaration` or the factory supplied by your transformation context instead. */
const updateConstructor: typeof factory.updateConstructorDeclaration;
/** @deprecated Use `factory.createGetAccessorDeclaration` or the factory supplied by your transformation context instead. */
const createGetAccessor: typeof factory.createGetAccessorDeclaration;
/** @deprecated Use `factory.updateGetAccessorDeclaration` or the factory supplied by your transformation context instead. */
const updateGetAccessor: typeof factory.updateGetAccessorDeclaration;
/** @deprecated Use `factory.createSetAccessorDeclaration` or the factory supplied by your transformation context instead. */
const createSetAccessor: typeof factory.createSetAccessorDeclaration;
/** @deprecated Use `factory.updateSetAccessorDeclaration` or the factory supplied by your transformation context instead. */
const updateSetAccessor: typeof factory.updateSetAccessorDeclaration;
/** @deprecated Use `factory.createCallSignature` or the factory supplied by your transformation context instead. */
const createCallSignature: typeof factory.createCallSignature;
/** @deprecated Use `factory.updateCallSignature` or the factory supplied by your transformation context instead. */
const updateCallSignature: typeof factory.updateCallSignature;
/** @deprecated Use `factory.createConstructSignature` or the factory supplied by your transformation context instead. */
const createConstructSignature: typeof factory.createConstructSignature;
/** @deprecated Use `factory.updateConstructSignature` or the factory supplied by your transformation context instead. */
const updateConstructSignature: typeof factory.updateConstructSignature;
/** @deprecated Use `factory.updateIndexSignature` or the factory supplied by your transformation context instead. */
const updateIndexSignature: typeof factory.updateIndexSignature;
/** @deprecated Use `factory.createKeywordTypeNode` or the factory supplied by your transformation context instead. */
const createKeywordTypeNode: typeof factory.createKeywordTypeNode;
/** @deprecated Use `factory.createTypePredicateNode` or the factory supplied by your transformation context instead. */
const createTypePredicateNodeWithModifier: typeof factory.createTypePredicateNode;
/** @deprecated Use `factory.updateTypePredicateNode` or the factory supplied by your transformation context instead. */
const updateTypePredicateNodeWithModifier: typeof factory.updateTypePredicateNode;
/** @deprecated Use `factory.createTypeReferenceNode` or the factory supplied by your transformation context instead. */
const createTypeReferenceNode: typeof factory.createTypeReferenceNode;
/** @deprecated Use `factory.updateTypeReferenceNode` or the factory supplied by your transformation context instead. */
const updateTypeReferenceNode: typeof factory.updateTypeReferenceNode;
/** @deprecated Use `factory.createFunctionTypeNode` or the factory supplied by your transformation context instead. */
const createFunctionTypeNode: typeof factory.createFunctionTypeNode;
/** @deprecated Use `factory.updateFunctionTypeNode` or the factory supplied by your transformation context instead. */
const updateFunctionTypeNode: typeof factory.updateFunctionTypeNode;
/** @deprecated Use `factory.createConstructorTypeNode` or the factory supplied by your transformation context instead. */
const createConstructorTypeNode: (typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode) => ConstructorTypeNode;
/** @deprecated Use `factory.updateConstructorTypeNode` or the factory supplied by your transformation context instead. */
const updateConstructorTypeNode: (node: ConstructorTypeNode, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode) => ConstructorTypeNode;
/** @deprecated Use `factory.createTypeQueryNode` or the factory supplied by your transformation context instead. */
const createTypeQueryNode: typeof factory.createTypeQueryNode;
/** @deprecated Use `factory.updateTypeQueryNode` or the factory supplied by your transformation context instead. */
const updateTypeQueryNode: typeof factory.updateTypeQueryNode;
/** @deprecated Use `factory.createTypeLiteralNode` or the factory supplied by your transformation context instead. */
const createTypeLiteralNode: typeof factory.createTypeLiteralNode;
/** @deprecated Use `factory.updateTypeLiteralNode` or the factory supplied by your transformation context instead. */
const updateTypeLiteralNode: typeof factory.updateTypeLiteralNode;
/** @deprecated Use `factory.createArrayTypeNode` or the factory supplied by your transformation context instead. */
const createArrayTypeNode: typeof factory.createArrayTypeNode;
/** @deprecated Use `factory.updateArrayTypeNode` or the factory supplied by your transformation context instead. */
const updateArrayTypeNode: typeof factory.updateArrayTypeNode;
/** @deprecated Use `factory.createTupleTypeNode` or the factory supplied by your transformation context instead. */
const createTupleTypeNode: typeof factory.createTupleTypeNode;
/** @deprecated Use `factory.updateTupleTypeNode` or the factory supplied by your transformation context instead. */
const updateTupleTypeNode: typeof factory.updateTupleTypeNode;
/** @deprecated Use `factory.createOptionalTypeNode` or the factory supplied by your transformation context instead. */
const createOptionalTypeNode: typeof factory.createOptionalTypeNode;
/** @deprecated Use `factory.updateOptionalTypeNode` or the factory supplied by your transformation context instead. */
const updateOptionalTypeNode: typeof factory.updateOptionalTypeNode;
/** @deprecated Use `factory.createRestTypeNode` or the factory supplied by your transformation context instead. */
const createRestTypeNode: typeof factory.createRestTypeNode;
/** @deprecated Use `factory.updateRestTypeNode` or the factory supplied by your transformation context instead. */
const updateRestTypeNode: typeof factory.updateRestTypeNode;
/** @deprecated Use `factory.createUnionTypeNode` or the factory supplied by your transformation context instead. */
const createUnionTypeNode: typeof factory.createUnionTypeNode;
/** @deprecated Use `factory.updateUnionTypeNode` or the factory supplied by your transformation context instead. */
const updateUnionTypeNode: typeof factory.updateUnionTypeNode;
/** @deprecated Use `factory.createIntersectionTypeNode` or the factory supplied by your transformation context instead. */
const createIntersectionTypeNode: typeof factory.createIntersectionTypeNode;
/** @deprecated Use `factory.updateIntersectionTypeNode` or the factory supplied by your transformation context instead. */
const updateIntersectionTypeNode: typeof factory.updateIntersectionTypeNode;
/** @deprecated Use `factory.createConditionalTypeNode` or the factory supplied by your transformation context instead. */
const createConditionalTypeNode: typeof factory.createConditionalTypeNode;
/** @deprecated Use `factory.updateConditionalTypeNode` or the factory supplied by your transformation context instead. */
const updateConditionalTypeNode: typeof factory.updateConditionalTypeNode;
/** @deprecated Use `factory.createInferTypeNode` or the factory supplied by your transformation context instead. */
const createInferTypeNode: typeof factory.createInferTypeNode;
/** @deprecated Use `factory.updateInferTypeNode` or the factory supplied by your transformation context instead. */
const updateInferTypeNode: typeof factory.updateInferTypeNode;
/** @deprecated Use `factory.createImportTypeNode` or the factory supplied by your transformation context instead. */
const createImportTypeNode: typeof factory.createImportTypeNode;
/** @deprecated Use `factory.updateImportTypeNode` or the factory supplied by your transformation context instead. */
const updateImportTypeNode: typeof factory.updateImportTypeNode;
/** @deprecated Use `factory.createParenthesizedType` or the factory supplied by your transformation context instead. */
const createParenthesizedType: typeof factory.createParenthesizedType;
/** @deprecated Use `factory.updateParenthesizedType` or the factory supplied by your transformation context instead. */
const updateParenthesizedType: typeof factory.updateParenthesizedType;
/** @deprecated Use `factory.createThisTypeNode` or the factory supplied by your transformation context instead. */
const createThisTypeNode: typeof factory.createThisTypeNode;
/** @deprecated Use `factory.updateTypeOperatorNode` or the factory supplied by your transformation context instead. */
const updateTypeOperatorNode: typeof factory.updateTypeOperatorNode;
/** @deprecated Use `factory.createIndexedAccessTypeNode` or the factory supplied by your transformation context instead. */
const createIndexedAccessTypeNode: typeof factory.createIndexedAccessTypeNode;
/** @deprecated Use `factory.updateIndexedAccessTypeNode` or the factory supplied by your transformation context instead. */
const updateIndexedAccessTypeNode: typeof factory.updateIndexedAccessTypeNode;
/** @deprecated Use `factory.createMappedTypeNode` or the factory supplied by your transformation context instead. */
const createMappedTypeNode: typeof factory.createMappedTypeNode;
/** @deprecated Use `factory.updateMappedTypeNode` or the factory supplied by your transformation context instead. */
const updateMappedTypeNode: typeof factory.updateMappedTypeNode;
/** @deprecated Use `factory.createLiteralTypeNode` or the factory supplied by your transformation context instead. */
const createLiteralTypeNode: typeof factory.createLiteralTypeNode;
/** @deprecated Use `factory.updateLiteralTypeNode` or the factory supplied by your transformation context instead. */
const updateLiteralTypeNode: typeof factory.updateLiteralTypeNode;
/** @deprecated Use `factory.createObjectBindingPattern` or the factory supplied by your transformation context instead. */
const createObjectBindingPattern: typeof factory.createObjectBindingPattern;
/** @deprecated Use `factory.updateObjectBindingPattern` or the factory supplied by your transformation context instead. */
const updateObjectBindingPattern: typeof factory.updateObjectBindingPattern;
/** @deprecated Use `factory.createArrayBindingPattern` or the factory supplied by your transformation context instead. */
const createArrayBindingPattern: typeof factory.createArrayBindingPattern;
/** @deprecated Use `factory.updateArrayBindingPattern` or the factory supplied by your transformation context instead. */
const updateArrayBindingPattern: typeof factory.updateArrayBindingPattern;
/** @deprecated Use `factory.createBindingElement` or the factory supplied by your transformation context instead. */
const createBindingElement: typeof factory.createBindingElement;
/** @deprecated Use `factory.updateBindingElement` or the factory supplied by your transformation context instead. */
const updateBindingElement: typeof factory.updateBindingElement;
/** @deprecated Use `factory.createArrayLiteralExpression` or the factory supplied by your transformation context instead. */
const createArrayLiteral: typeof factory.createArrayLiteralExpression;
/** @deprecated Use `factory.updateArrayLiteralExpression` or the factory supplied by your transformation context instead. */
const updateArrayLiteral: typeof factory.updateArrayLiteralExpression;
/** @deprecated Use `factory.createObjectLiteralExpression` or the factory supplied by your transformation context instead. */
const createObjectLiteral: typeof factory.createObjectLiteralExpression;
/** @deprecated Use `factory.updateObjectLiteralExpression` or the factory supplied by your transformation context instead. */
const updateObjectLiteral: typeof factory.updateObjectLiteralExpression;
/** @deprecated Use `factory.createPropertyAccessExpression` or the factory supplied by your transformation context instead. */
const createPropertyAccess: typeof factory.createPropertyAccessExpression;
/** @deprecated Use `factory.updatePropertyAccessExpression` or the factory supplied by your transformation context instead. */
const updatePropertyAccess: typeof factory.updatePropertyAccessExpression;
/** @deprecated Use `factory.createPropertyAccessChain` or the factory supplied by your transformation context instead. */
const createPropertyAccessChain: typeof factory.createPropertyAccessChain;
/** @deprecated Use `factory.updatePropertyAccessChain` or the factory supplied by your transformation context instead. */
const updatePropertyAccessChain: typeof factory.updatePropertyAccessChain;
/** @deprecated Use `factory.createElementAccessExpression` or the factory supplied by your transformation context instead. */
const createElementAccess: typeof factory.createElementAccessExpression;
/** @deprecated Use `factory.updateElementAccessExpression` or the factory supplied by your transformation context instead. */
const updateElementAccess: typeof factory.updateElementAccessExpression;
/** @deprecated Use `factory.createElementAccessChain` or the factory supplied by your transformation context instead. */
const createElementAccessChain: typeof factory.createElementAccessChain;
/** @deprecated Use `factory.updateElementAccessChain` or the factory supplied by your transformation context instead. */
const updateElementAccessChain: typeof factory.updateElementAccessChain;
/** @deprecated Use `factory.createCallExpression` or the factory supplied by your transformation context instead. */
const createCall: typeof factory.createCallExpression;
/** @deprecated Use `factory.updateCallExpression` or the factory supplied by your transformation context instead. */
const updateCall: typeof factory.updateCallExpression;
/** @deprecated Use `factory.createCallChain` or the factory supplied by your transformation context instead. */
const createCallChain: typeof factory.createCallChain;
/** @deprecated Use `factory.updateCallChain` or the factory supplied by your transformation context instead. */
const updateCallChain: typeof factory.updateCallChain;
/** @deprecated Use `factory.createNewExpression` or the factory supplied by your transformation context instead. */
const createNew: typeof factory.createNewExpression;
/** @deprecated Use `factory.updateNewExpression` or the factory supplied by your transformation context instead. */
const updateNew: typeof factory.updateNewExpression;
/** @deprecated Use `factory.createTypeAssertion` or the factory supplied by your transformation context instead. */
const createTypeAssertion: typeof factory.createTypeAssertion;
/** @deprecated Use `factory.updateTypeAssertion` or the factory supplied by your transformation context instead. */
const updateTypeAssertion: typeof factory.updateTypeAssertion;
/** @deprecated Use `factory.createParenthesizedExpression` or the factory supplied by your transformation context instead. */
const createParen: typeof factory.createParenthesizedExpression;
/** @deprecated Use `factory.updateParenthesizedExpression` or the factory supplied by your transformation context instead. */
const updateParen: typeof factory.updateParenthesizedExpression;
/** @deprecated Use `factory.createFunctionExpression` or the factory supplied by your transformation context instead. */
const createFunctionExpression: typeof factory.createFunctionExpression;
/** @deprecated Use `factory.updateFunctionExpression` or the factory supplied by your transformation context instead. */
const updateFunctionExpression: typeof factory.updateFunctionExpression;
/** @deprecated Use `factory.createDeleteExpression` or the factory supplied by your transformation context instead. */
const createDelete: typeof factory.createDeleteExpression;
/** @deprecated Use `factory.updateDeleteExpression` or the factory supplied by your transformation context instead. */
const updateDelete: typeof factory.updateDeleteExpression;
/** @deprecated Use `factory.createTypeOfExpression` or the factory supplied by your transformation context instead. */
const createTypeOf: typeof factory.createTypeOfExpression;
/** @deprecated Use `factory.updateTypeOfExpression` or the factory supplied by your transformation context instead. */
const updateTypeOf: typeof factory.updateTypeOfExpression;
/** @deprecated Use `factory.createVoidExpression` or the factory supplied by your transformation context instead. */
const createVoid: typeof factory.createVoidExpression;
/** @deprecated Use `factory.updateVoidExpression` or the factory supplied by your transformation context instead. */
const updateVoid: typeof factory.updateVoidExpression;
/** @deprecated Use `factory.createAwaitExpression` or the factory supplied by your transformation context instead. */
const createAwait: typeof factory.createAwaitExpression;
/** @deprecated Use `factory.updateAwaitExpression` or the factory supplied by your transformation context instead. */
const updateAwait: typeof factory.updateAwaitExpression;
/** @deprecated Use `factory.createPrefixExpression` or the factory supplied by your transformation context instead. */
const createPrefix: typeof factory.createPrefixUnaryExpression;
/** @deprecated Use `factory.updatePrefixExpression` or the factory supplied by your transformation context instead. */
const updatePrefix: typeof factory.updatePrefixUnaryExpression;
/** @deprecated Use `factory.createPostfixUnaryExpression` or the factory supplied by your transformation context instead. */
const createPostfix: typeof factory.createPostfixUnaryExpression;
/** @deprecated Use `factory.updatePostfixUnaryExpression` or the factory supplied by your transformation context instead. */
const updatePostfix: typeof factory.updatePostfixUnaryExpression;
/** @deprecated Use `factory.createBinaryExpression` or the factory supplied by your transformation context instead. */
const createBinary: typeof factory.createBinaryExpression;
/** @deprecated Use `factory.updateConditionalExpression` or the factory supplied by your transformation context instead. */
const updateConditional: typeof factory.updateConditionalExpression;
/** @deprecated Use `factory.createTemplateExpression` or the factory supplied by your transformation context instead. */
const createTemplateExpression: typeof factory.createTemplateExpression;
/** @deprecated Use `factory.updateTemplateExpression` or the factory supplied by your transformation context instead. */
const updateTemplateExpression: typeof factory.updateTemplateExpression;
/** @deprecated Use `factory.createTemplateHead` or the factory supplied by your transformation context instead. */
const createTemplateHead: typeof factory.createTemplateHead;
/** @deprecated Use `factory.createTemplateMiddle` or the factory supplied by your transformation context instead. */
const createTemplateMiddle: typeof factory.createTemplateMiddle;
/** @deprecated Use `factory.createTemplateTail` or the factory supplied by your transformation context instead. */
const createTemplateTail: typeof factory.createTemplateTail;
/** @deprecated Use `factory.createNoSubstitutionTemplateLiteral` or the factory supplied by your transformation context instead. */
const createNoSubstitutionTemplateLiteral: typeof factory.createNoSubstitutionTemplateLiteral;
/** @deprecated Use `factory.updateYieldExpression` or the factory supplied by your transformation context instead. */
const updateYield: typeof factory.updateYieldExpression;
/** @deprecated Use `factory.createSpreadExpression` or the factory supplied by your transformation context instead. */
const createSpread: typeof factory.createSpreadElement;
/** @deprecated Use `factory.updateSpreadExpression` or the factory supplied by your transformation context instead. */
const updateSpread: typeof factory.updateSpreadElement;
/** @deprecated Use `factory.createOmittedExpression` or the factory supplied by your transformation context instead. */
const createOmittedExpression: typeof factory.createOmittedExpression;
/** @deprecated Use `factory.createAsExpression` or the factory supplied by your transformation context instead. */
const createAsExpression: typeof factory.createAsExpression;
/** @deprecated Use `factory.updateAsExpression` or the factory supplied by your transformation context instead. */
const updateAsExpression: typeof factory.updateAsExpression;
/** @deprecated Use `factory.createNonNullExpression` or the factory supplied by your transformation context instead. */
const createNonNullExpression: typeof factory.createNonNullExpression;
/** @deprecated Use `factory.updateNonNullExpression` or the factory supplied by your transformation context instead. */
const updateNonNullExpression: typeof factory.updateNonNullExpression;
/** @deprecated Use `factory.createNonNullChain` or the factory supplied by your transformation context instead. */
const createNonNullChain: typeof factory.createNonNullChain;
/** @deprecated Use `factory.updateNonNullChain` or the factory supplied by your transformation context instead. */
const updateNonNullChain: typeof factory.updateNonNullChain;
/** @deprecated Use `factory.createMetaProperty` or the factory supplied by your transformation context instead. */
const createMetaProperty: typeof factory.createMetaProperty;
/** @deprecated Use `factory.updateMetaProperty` or the factory supplied by your transformation context instead. */
const updateMetaProperty: typeof factory.updateMetaProperty;
/** @deprecated Use `factory.createTemplateSpan` or the factory supplied by your transformation context instead. */
const createTemplateSpan: typeof factory.createTemplateSpan;
/** @deprecated Use `factory.updateTemplateSpan` or the factory supplied by your transformation context instead. */
const updateTemplateSpan: typeof factory.updateTemplateSpan;
/** @deprecated Use `factory.createSemicolonClassElement` or the factory supplied by your transformation context instead. */
const createSemicolonClassElement: typeof factory.createSemicolonClassElement;
/** @deprecated Use `factory.createBlock` or the factory supplied by your transformation context instead. */
const createBlock: typeof factory.createBlock;
/** @deprecated Use `factory.updateBlock` or the factory supplied by your transformation context instead. */
const updateBlock: typeof factory.updateBlock;
/** @deprecated Use `factory.createVariableStatement` or the factory supplied by your transformation context instead. */
const createVariableStatement: typeof factory.createVariableStatement;
/** @deprecated Use `factory.updateVariableStatement` or the factory supplied by your transformation context instead. */
const updateVariableStatement: typeof factory.updateVariableStatement;
/** @deprecated Use `factory.createEmptyStatement` or the factory supplied by your transformation context instead. */
const createEmptyStatement: typeof factory.createEmptyStatement;
/** @deprecated Use `factory.createExpressionStatement` or the factory supplied by your transformation context instead. */
const createExpressionStatement: typeof factory.createExpressionStatement;
/** @deprecated Use `factory.updateExpressionStatement` or the factory supplied by your transformation context instead. */
const updateExpressionStatement: typeof factory.updateExpressionStatement;
/** @deprecated Use `factory.createExpressionStatement` or the factory supplied by your transformation context instead. */
const createStatement: typeof factory.createExpressionStatement;
/** @deprecated Use `factory.updateExpressionStatement` or the factory supplied by your transformation context instead. */
const updateStatement: typeof factory.updateExpressionStatement;
/** @deprecated Use `factory.createIfStatement` or the factory supplied by your transformation context instead. */
const createIf: typeof factory.createIfStatement;
/** @deprecated Use `factory.updateIfStatement` or the factory supplied by your transformation context instead. */
const updateIf: typeof factory.updateIfStatement;
/** @deprecated Use `factory.createDoStatement` or the factory supplied by your transformation context instead. */
const createDo: typeof factory.createDoStatement;
/** @deprecated Use `factory.updateDoStatement` or the factory supplied by your transformation context instead. */
const updateDo: typeof factory.updateDoStatement;
/** @deprecated Use `factory.createWhileStatement` or the factory supplied by your transformation context instead. */
const createWhile: typeof factory.createWhileStatement;
/** @deprecated Use `factory.updateWhileStatement` or the factory supplied by your transformation context instead. */
const updateWhile: typeof factory.updateWhileStatement;
/** @deprecated Use `factory.createForStatement` or the factory supplied by your transformation context instead. */
const createFor: typeof factory.createForStatement;
/** @deprecated Use `factory.updateForStatement` or the factory supplied by your transformation context instead. */
const updateFor: typeof factory.updateForStatement;
/** @deprecated Use `factory.createForInStatement` or the factory supplied by your transformation context instead. */
const createForIn: typeof factory.createForInStatement;
/** @deprecated Use `factory.updateForInStatement` or the factory supplied by your transformation context instead. */
const updateForIn: typeof factory.updateForInStatement;
/** @deprecated Use `factory.createForOfStatement` or the factory supplied by your transformation context instead. */
const createForOf: typeof factory.createForOfStatement;
/** @deprecated Use `factory.updateForOfStatement` or the factory supplied by your transformation context instead. */
const updateForOf: typeof factory.updateForOfStatement;
/** @deprecated Use `factory.createContinueStatement` or the factory supplied by your transformation context instead. */
const createContinue: typeof factory.createContinueStatement;
/** @deprecated Use `factory.updateContinueStatement` or the factory supplied by your transformation context instead. */
const updateContinue: typeof factory.updateContinueStatement;
/** @deprecated Use `factory.createBreakStatement` or the factory supplied by your transformation context instead. */
const createBreak: typeof factory.createBreakStatement;
/** @deprecated Use `factory.updateBreakStatement` or the factory supplied by your transformation context instead. */
const updateBreak: typeof factory.updateBreakStatement;
/** @deprecated Use `factory.createReturnStatement` or the factory supplied by your transformation context instead. */
const createReturn: typeof factory.createReturnStatement;
/** @deprecated Use `factory.updateReturnStatement` or the factory supplied by your transformation context instead. */
const updateReturn: typeof factory.updateReturnStatement;
/** @deprecated Use `factory.createWithStatement` or the factory supplied by your transformation context instead. */
const createWith: typeof factory.createWithStatement;
/** @deprecated Use `factory.updateWithStatement` or the factory supplied by your transformation context instead. */
const updateWith: typeof factory.updateWithStatement;
/** @deprecated Use `factory.createSwitchStatement` or the factory supplied by your transformation context instead. */
const createSwitch: typeof factory.createSwitchStatement;
/** @deprecated Use `factory.updateSwitchStatement` or the factory supplied by your transformation context instead. */
const updateSwitch: typeof factory.updateSwitchStatement;
/** @deprecated Use `factory.createLabelStatement` or the factory supplied by your transformation context instead. */
const createLabel: typeof factory.createLabeledStatement;
/** @deprecated Use `factory.updateLabelStatement` or the factory supplied by your transformation context instead. */
const updateLabel: typeof factory.updateLabeledStatement;
/** @deprecated Use `factory.createThrowStatement` or the factory supplied by your transformation context instead. */
const createThrow: typeof factory.createThrowStatement;
/** @deprecated Use `factory.updateThrowStatement` or the factory supplied by your transformation context instead. */
const updateThrow: typeof factory.updateThrowStatement;
/** @deprecated Use `factory.createTryStatement` or the factory supplied by your transformation context instead. */
const createTry: typeof factory.createTryStatement;
/** @deprecated Use `factory.updateTryStatement` or the factory supplied by your transformation context instead. */
const updateTry: typeof factory.updateTryStatement;
/** @deprecated Use `factory.createDebuggerStatement` or the factory supplied by your transformation context instead. */
const createDebuggerStatement: typeof factory.createDebuggerStatement;
/** @deprecated Use `factory.createVariableDeclarationList` or the factory supplied by your transformation context instead. */
const createVariableDeclarationList: typeof factory.createVariableDeclarationList;
/** @deprecated Use `factory.updateVariableDeclarationList` or the factory supplied by your transformation context instead. */
const updateVariableDeclarationList: typeof factory.updateVariableDeclarationList;
/** @deprecated Use `factory.createFunctionDeclaration` or the factory supplied by your transformation context instead. */
const createFunctionDeclaration: typeof factory.createFunctionDeclaration;
/** @deprecated Use `factory.updateFunctionDeclaration` or the factory supplied by your transformation context instead. */
const updateFunctionDeclaration: typeof factory.updateFunctionDeclaration;
/** @deprecated Use `factory.createClassDeclaration` or the factory supplied by your transformation context instead. */
const createClassDeclaration: typeof factory.createClassDeclaration;
/** @deprecated Use `factory.updateClassDeclaration` or the factory supplied by your transformation context instead. */
const updateClassDeclaration: typeof factory.updateClassDeclaration;
/** @deprecated Use `factory.createInterfaceDeclaration` or the factory supplied by your transformation context instead. */
const createInterfaceDeclaration: typeof factory.createInterfaceDeclaration;
/** @deprecated Use `factory.updateInterfaceDeclaration` or the factory supplied by your transformation context instead. */
const updateInterfaceDeclaration: typeof factory.updateInterfaceDeclaration;
/** @deprecated Use `factory.createTypeAliasDeclaration` or the factory supplied by your transformation context instead. */
const createTypeAliasDeclaration: typeof factory.createTypeAliasDeclaration;
/** @deprecated Use `factory.updateTypeAliasDeclaration` or the factory supplied by your transformation context instead. */
const updateTypeAliasDeclaration: typeof factory.updateTypeAliasDeclaration;
/** @deprecated Use `factory.createEnumDeclaration` or the factory supplied by your transformation context instead. */
const createEnumDeclaration: typeof factory.createEnumDeclaration;
/** @deprecated Use `factory.updateEnumDeclaration` or the factory supplied by your transformation context instead. */
const updateEnumDeclaration: typeof factory.updateEnumDeclaration;
/** @deprecated Use `factory.createModuleDeclaration` or the factory supplied by your transformation context instead. */
const createModuleDeclaration: typeof factory.createModuleDeclaration;
/** @deprecated Use `factory.updateModuleDeclaration` or the factory supplied by your transformation context instead. */
const updateModuleDeclaration: typeof factory.updateModuleDeclaration;
/** @deprecated Use `factory.createModuleBlock` or the factory supplied by your transformation context instead. */
const createModuleBlock: typeof factory.createModuleBlock;
/** @deprecated Use `factory.updateModuleBlock` or the factory supplied by your transformation context instead. */
const updateModuleBlock: typeof factory.updateModuleBlock;
/** @deprecated Use `factory.createCaseBlock` or the factory supplied by your transformation context instead. */
const createCaseBlock: typeof factory.createCaseBlock;
/** @deprecated Use `factory.updateCaseBlock` or the factory supplied by your transformation context instead. */
const updateCaseBlock: typeof factory.updateCaseBlock;
/** @deprecated Use `factory.createNamespaceExportDeclaration` or the factory supplied by your transformation context instead. */
const createNamespaceExportDeclaration: typeof factory.createNamespaceExportDeclaration;
/** @deprecated Use `factory.updateNamespaceExportDeclaration` or the factory supplied by your transformation context instead. */
const updateNamespaceExportDeclaration: typeof factory.updateNamespaceExportDeclaration;
/** @deprecated Use `factory.createImportEqualsDeclaration` or the factory supplied by your transformation context instead. */
const createImportEqualsDeclaration: typeof factory.createImportEqualsDeclaration;
/** @deprecated Use `factory.updateImportEqualsDeclaration` or the factory supplied by your transformation context instead. */
const updateImportEqualsDeclaration: typeof factory.updateImportEqualsDeclaration;
/** @deprecated Use `factory.createImportDeclaration` or the factory supplied by your transformation context instead. */
const createImportDeclaration: typeof factory.createImportDeclaration;
/** @deprecated Use `factory.updateImportDeclaration` or the factory supplied by your transformation context instead. */
const updateImportDeclaration: typeof factory.updateImportDeclaration;
/** @deprecated Use `factory.createNamespaceImport` or the factory supplied by your transformation context instead. */
const createNamespaceImport: typeof factory.createNamespaceImport;
/** @deprecated Use `factory.updateNamespaceImport` or the factory supplied by your transformation context instead. */
const updateNamespaceImport: typeof factory.updateNamespaceImport;
/** @deprecated Use `factory.createNamedImports` or the factory supplied by your transformation context instead. */
const createNamedImports: typeof factory.createNamedImports;
/** @deprecated Use `factory.updateNamedImports` or the factory supplied by your transformation context instead. */
const updateNamedImports: typeof factory.updateNamedImports;
/** @deprecated Use `factory.createImportSpecifier` or the factory supplied by your transformation context instead. */
const createImportSpecifier: typeof factory.createImportSpecifier;
/** @deprecated Use `factory.updateImportSpecifier` or the factory supplied by your transformation context instead. */
const updateImportSpecifier: typeof factory.updateImportSpecifier;
/** @deprecated Use `factory.createExportAssignment` or the factory supplied by your transformation context instead. */
const createExportAssignment: typeof factory.createExportAssignment;
/** @deprecated Use `factory.updateExportAssignment` or the factory supplied by your transformation context instead. */
const updateExportAssignment: typeof factory.updateExportAssignment;
/** @deprecated Use `factory.createNamedExports` or the factory supplied by your transformation context instead. */
const createNamedExports: typeof factory.createNamedExports;
/** @deprecated Use `factory.updateNamedExports` or the factory supplied by your transformation context instead. */
const updateNamedExports: typeof factory.updateNamedExports;
/** @deprecated Use `factory.createExportSpecifier` or the factory supplied by your transformation context instead. */
const createExportSpecifier: typeof factory.createExportSpecifier;
/** @deprecated Use `factory.updateExportSpecifier` or the factory supplied by your transformation context instead. */
const updateExportSpecifier: typeof factory.updateExportSpecifier;
/** @deprecated Use `factory.createExternalModuleReference` or the factory supplied by your transformation context instead. */
const createExternalModuleReference: typeof factory.createExternalModuleReference;
/** @deprecated Use `factory.updateExternalModuleReference` or the factory supplied by your transformation context instead. */
const updateExternalModuleReference: typeof factory.updateExternalModuleReference;
/** @deprecated Use `factory.createJSDocTypeExpression` or the factory supplied by your transformation context instead. */
const createJSDocTypeExpression: typeof factory.createJSDocTypeExpression;
/** @deprecated Use `factory.createJSDocTypeTag` or the factory supplied by your transformation context instead. */
const createJSDocTypeTag: typeof factory.createJSDocTypeTag;
/** @deprecated Use `factory.createJSDocReturnTag` or the factory supplied by your transformation context instead. */
const createJSDocReturnTag: typeof factory.createJSDocReturnTag;
/** @deprecated Use `factory.createJSDocThisTag` or the factory supplied by your transformation context instead. */
const createJSDocThisTag: typeof factory.createJSDocThisTag;
/** @deprecated Use `factory.createJSDocComment` or the factory supplied by your transformation context instead. */
const createJSDocComment: typeof factory.createJSDocComment;
/** @deprecated Use `factory.createJSDocParameterTag` or the factory supplied by your transformation context instead. */
const createJSDocParameterTag: typeof factory.createJSDocParameterTag;
/** @deprecated Use `factory.createJSDocClassTag` or the factory supplied by your transformation context instead. */
const createJSDocClassTag: typeof factory.createJSDocClassTag;
/** @deprecated Use `factory.createJSDocAugmentsTag` or the factory supplied by your transformation context instead. */
const createJSDocAugmentsTag: typeof factory.createJSDocAugmentsTag;
/** @deprecated Use `factory.createJSDocEnumTag` or the factory supplied by your transformation context instead. */
const createJSDocEnumTag: typeof factory.createJSDocEnumTag;
/** @deprecated Use `factory.createJSDocTemplateTag` or the factory supplied by your transformation context instead. */
const createJSDocTemplateTag: typeof factory.createJSDocTemplateTag;
/** @deprecated Use `factory.createJSDocTypedefTag` or the factory supplied by your transformation context instead. */
const createJSDocTypedefTag: typeof factory.createJSDocTypedefTag;
/** @deprecated Use `factory.createJSDocCallbackTag` or the factory supplied by your transformation context instead. */
const createJSDocCallbackTag: typeof factory.createJSDocCallbackTag;
/** @deprecated Use `factory.createJSDocSignature` or the factory supplied by your transformation context instead. */
const createJSDocSignature: typeof factory.createJSDocSignature;
/** @deprecated Use `factory.createJSDocPropertyTag` or the factory supplied by your transformation context instead. */
const createJSDocPropertyTag: typeof factory.createJSDocPropertyTag;
/** @deprecated Use `factory.createJSDocTypeLiteral` or the factory supplied by your transformation context instead. */
const createJSDocTypeLiteral: typeof factory.createJSDocTypeLiteral;
/** @deprecated Use `factory.createJSDocImplementsTag` or the factory supplied by your transformation context instead. */
const createJSDocImplementsTag: typeof factory.createJSDocImplementsTag;
/** @deprecated Use `factory.createJSDocAuthorTag` or the factory supplied by your transformation context instead. */
const createJSDocAuthorTag: typeof factory.createJSDocAuthorTag;
/** @deprecated Use `factory.createJSDocPublicTag` or the factory supplied by your transformation context instead. */
const createJSDocPublicTag: typeof factory.createJSDocPublicTag;
/** @deprecated Use `factory.createJSDocPrivateTag` or the factory supplied by your transformation context instead. */
const createJSDocPrivateTag: typeof factory.createJSDocPrivateTag;
/** @deprecated Use `factory.createJSDocProtectedTag` or the factory supplied by your transformation context instead. */
const createJSDocProtectedTag: typeof factory.createJSDocProtectedTag;
/** @deprecated Use `factory.createJSDocReadonlyTag` or the factory supplied by your transformation context instead. */
const createJSDocReadonlyTag: typeof factory.createJSDocReadonlyTag;
/** @deprecated Use `factory.createJSDocUnknownTag` or the factory supplied by your transformation context instead. */
const createJSDocTag: typeof factory.createJSDocUnknownTag;
/** @deprecated Use `factory.createJsxElement` or the factory supplied by your transformation context instead. */
const createJsxElement: typeof factory.createJsxElement;
/** @deprecated Use `factory.updateJsxElement` or the factory supplied by your transformation context instead. */
const updateJsxElement: typeof factory.updateJsxElement;
/** @deprecated Use `factory.createJsxSelfClosingElement` or the factory supplied by your transformation context instead. */
const createJsxSelfClosingElement: typeof factory.createJsxSelfClosingElement;
/** @deprecated Use `factory.updateJsxSelfClosingElement` or the factory supplied by your transformation context instead. */
const updateJsxSelfClosingElement: typeof factory.updateJsxSelfClosingElement;
/** @deprecated Use `factory.createJsxOpeningElement` or the factory supplied by your transformation context instead. */
const createJsxOpeningElement: typeof factory.createJsxOpeningElement;
/** @deprecated Use `factory.updateJsxOpeningElement` or the factory supplied by your transformation context instead. */
const updateJsxOpeningElement: typeof factory.updateJsxOpeningElement;
/** @deprecated Use `factory.createJsxClosingElement` or the factory supplied by your transformation context instead. */
const createJsxClosingElement: typeof factory.createJsxClosingElement;
/** @deprecated Use `factory.updateJsxClosingElement` or the factory supplied by your transformation context instead. */
const updateJsxClosingElement: typeof factory.updateJsxClosingElement;
/** @deprecated Use `factory.createJsxFragment` or the factory supplied by your transformation context instead. */
const createJsxFragment: typeof factory.createJsxFragment;
/** @deprecated Use `factory.createJsxText` or the factory supplied by your transformation context instead. */
const createJsxText: typeof factory.createJsxText;
/** @deprecated Use `factory.updateJsxText` or the factory supplied by your transformation context instead. */
const updateJsxText: typeof factory.updateJsxText;
/** @deprecated Use `factory.createJsxOpeningFragment` or the factory supplied by your transformation context instead. */
const createJsxOpeningFragment: typeof factory.createJsxOpeningFragment;
/** @deprecated Use `factory.createJsxJsxClosingFragment` or the factory supplied by your transformation context instead. */
const createJsxJsxClosingFragment: typeof factory.createJsxJsxClosingFragment;
/** @deprecated Use `factory.updateJsxFragment` or the factory supplied by your transformation context instead. */
const updateJsxFragment: typeof factory.updateJsxFragment;
/** @deprecated Use `factory.createJsxAttribute` or the factory supplied by your transformation context instead. */
const createJsxAttribute: typeof factory.createJsxAttribute;
/** @deprecated Use `factory.updateJsxAttribute` or the factory supplied by your transformation context instead. */
const updateJsxAttribute: typeof factory.updateJsxAttribute;
/** @deprecated Use `factory.createJsxAttributes` or the factory supplied by your transformation context instead. */
const createJsxAttributes: typeof factory.createJsxAttributes;
/** @deprecated Use `factory.updateJsxAttributes` or the factory supplied by your transformation context instead. */
const updateJsxAttributes: typeof factory.updateJsxAttributes;
/** @deprecated Use `factory.createJsxSpreadAttribute` or the factory supplied by your transformation context instead. */
const createJsxSpreadAttribute: typeof factory.createJsxSpreadAttribute;
/** @deprecated Use `factory.updateJsxSpreadAttribute` or the factory supplied by your transformation context instead. */
const updateJsxSpreadAttribute: typeof factory.updateJsxSpreadAttribute;
/** @deprecated Use `factory.createJsxExpression` or the factory supplied by your transformation context instead. */
const createJsxExpression: typeof factory.createJsxExpression;
/** @deprecated Use `factory.updateJsxExpression` or the factory supplied by your transformation context instead. */
const updateJsxExpression: typeof factory.updateJsxExpression;
/** @deprecated Use `factory.createCaseClause` or the factory supplied by your transformation context instead. */
const createCaseClause: typeof factory.createCaseClause;
/** @deprecated Use `factory.updateCaseClause` or the factory supplied by your transformation context instead. */
const updateCaseClause: typeof factory.updateCaseClause;
/** @deprecated Use `factory.createDefaultClause` or the factory supplied by your transformation context instead. */
const createDefaultClause: typeof factory.createDefaultClause;
/** @deprecated Use `factory.updateDefaultClause` or the factory supplied by your transformation context instead. */
const updateDefaultClause: typeof factory.updateDefaultClause;
/** @deprecated Use `factory.createHeritageClause` or the factory supplied by your transformation context instead. */
const createHeritageClause: typeof factory.createHeritageClause;
/** @deprecated Use `factory.updateHeritageClause` or the factory supplied by your transformation context instead. */
const updateHeritageClause: typeof factory.updateHeritageClause;
/** @deprecated Use `factory.createCatchClause` or the factory supplied by your transformation context instead. */
const createCatchClause: typeof factory.createCatchClause;
/** @deprecated Use `factory.updateCatchClause` or the factory supplied by your transformation context instead. */
const updateCatchClause: typeof factory.updateCatchClause;
/** @deprecated Use `factory.createPropertyAssignment` or the factory supplied by your transformation context instead. */
const createPropertyAssignment: typeof factory.createPropertyAssignment;
/** @deprecated Use `factory.updatePropertyAssignment` or the factory supplied by your transformation context instead. */
const updatePropertyAssignment: typeof factory.updatePropertyAssignment;
/** @deprecated Use `factory.createShorthandPropertyAssignment` or the factory supplied by your transformation context instead. */
const createShorthandPropertyAssignment: typeof factory.createShorthandPropertyAssignment;
/** @deprecated Use `factory.updateShorthandPropertyAssignment` or the factory supplied by your transformation context instead. */
const updateShorthandPropertyAssignment: typeof factory.updateShorthandPropertyAssignment;
/** @deprecated Use `factory.createSpreadAssignment` or the factory supplied by your transformation context instead. */
const createSpreadAssignment: typeof factory.createSpreadAssignment;
/** @deprecated Use `factory.updateSpreadAssignment` or the factory supplied by your transformation context instead. */
const updateSpreadAssignment: typeof factory.updateSpreadAssignment;
/** @deprecated Use `factory.createEnumMember` or the factory supplied by your transformation context instead. */
const createEnumMember: typeof factory.createEnumMember;
/** @deprecated Use `factory.updateEnumMember` or the factory supplied by your transformation context instead. */
const updateEnumMember: typeof factory.updateEnumMember;
/** @deprecated Use `factory.updateSourceFile` or the factory supplied by your transformation context instead. */
const updateSourceFileNode: typeof factory.updateSourceFile;
/** @deprecated Use `factory.createNotEmittedStatement` or the factory supplied by your transformation context instead. */
const createNotEmittedStatement: typeof factory.createNotEmittedStatement;
/** @deprecated Use `factory.createPartiallyEmittedExpression` or the factory supplied by your transformation context instead. */
const createPartiallyEmittedExpression: typeof factory.createPartiallyEmittedExpression;
/** @deprecated Use `factory.updatePartiallyEmittedExpression` or the factory supplied by your transformation context instead. */
const updatePartiallyEmittedExpression: typeof factory.updatePartiallyEmittedExpression;
/** @deprecated Use `factory.createCommaListExpression` or the factory supplied by your transformation context instead. */
const createCommaList: typeof factory.createCommaListExpression;
/** @deprecated Use `factory.updateCommaListExpression` or the factory supplied by your transformation context instead. */
const updateCommaList: typeof factory.updateCommaListExpression;
/** @deprecated Use `factory.createBundle` or the factory supplied by your transformation context instead. */
const createBundle: typeof factory.createBundle;
/** @deprecated Use `factory.updateBundle` or the factory supplied by your transformation context instead. */
const updateBundle: typeof factory.updateBundle;
/** @deprecated Use `factory.createImmediatelyInvokedFunctionExpression` or the factory supplied by your transformation context instead. */
const createImmediatelyInvokedFunctionExpression: typeof factory.createImmediatelyInvokedFunctionExpression;
/** @deprecated Use `factory.createImmediatelyInvokedArrowFunction` or the factory supplied by your transformation context instead. */
const createImmediatelyInvokedArrowFunction: typeof factory.createImmediatelyInvokedArrowFunction;
/** @deprecated Use `factory.createVoidZero` or the factory supplied by your transformation context instead. */
const createVoidZero: typeof factory.createVoidZero;
/** @deprecated Use `factory.createExportDefault` or the factory supplied by your transformation context instead. */
const createExportDefault: typeof factory.createExportDefault;
/** @deprecated Use `factory.createExternalModuleExport` or the factory supplied by your transformation context instead. */
const createExternalModuleExport: typeof factory.createExternalModuleExport;
/** @deprecated Use `factory.createNamespaceExport` or the factory supplied by your transformation context instead. */
const createNamespaceExport: typeof factory.createNamespaceExport;
/** @deprecated Use `factory.updateNamespaceExport` or the factory supplied by your transformation context instead. */
const updateNamespaceExport: typeof factory.updateNamespaceExport;
/** @deprecated Use `factory.createToken` or the factory supplied by your transformation context instead. */
const createToken: <TKind extends SyntaxKind>(kind: TKind) => Token<TKind>;
/** @deprecated Use `factory.createIdentifier` or the factory supplied by your transformation context instead. */
const createIdentifier: (text: string) => Identifier;
/** @deprecated Use `factory.createTempVariable` or the factory supplied by your transformation context instead. */
const createTempVariable: (recordTempVariable: ((node: Identifier) => void) | undefined) => Identifier;
/** @deprecated Use `factory.getGeneratedNameForNode` or the factory supplied by your transformation context instead. */
const getGeneratedNameForNode: (node: Node | undefined) => Identifier;
/** @deprecated Use `factory.createUniqueName(text, GeneratedIdentifierFlags.Optimistic)` or the factory supplied by your transformation context instead. */
const createOptimisticUniqueName: (text: string) => Identifier;
/** @deprecated Use `factory.createUniqueName(text, GeneratedIdentifierFlags.Optimistic | GeneratedIdentifierFlags.FileLevel)` or the factory supplied by your transformation context instead. */
const createFileLevelUniqueName: (text: string) => Identifier;
/** @deprecated Use `factory.createIndexSignature` or the factory supplied by your transformation context instead. */
const createIndexSignature: (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode) => IndexSignatureDeclaration;
/** @deprecated Use `factory.createTypePredicateNode` or the factory supplied by your transformation context instead. */
const createTypePredicateNode: (parameterName: Identifier | ThisTypeNode | string, type: TypeNode) => TypePredicateNode;
/** @deprecated Use `factory.updateTypePredicateNode` or the factory supplied by your transformation context instead. */
const updateTypePredicateNode: (node: TypePredicateNode, parameterName: Identifier | ThisTypeNode, type: TypeNode) => TypePredicateNode;
/** @deprecated Use `factory.createStringLiteral`, `factory.createStringLiteralFromNode`, `factory.createNumericLiteral`, `factory.createBigIntLiteral`, `factory.createTrue`, `factory.createFalse`, or the factory supplied by your transformation context instead. */
const createLiteral: {
(value: string | StringLiteral | NoSubstitutionTemplateLiteral | NumericLiteral | Identifier): StringLiteral;
(value: number | PseudoBigInt): NumericLiteral;
(value: boolean): BooleanLiteral;
(value: string | number | PseudoBigInt | boolean): PrimaryExpression;
};
/** @deprecated Use `factory.createMethodSignature` or the factory supplied by your transformation context instead. */
const createMethodSignature: (typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, name: string | PropertyName, questionToken: QuestionToken | undefined) => MethodSignature;
/** @deprecated Use `factory.updateMethodSignature` or the factory supplied by your transformation context instead. */
const updateMethodSignature: (node: MethodSignature, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode | undefined, name: PropertyName, questionToken: QuestionToken | undefined) => MethodSignature;
/** @deprecated Use `factory.createTypeOperatorNode` or the factory supplied by your transformation context instead. */
const createTypeOperatorNode: {
(type: TypeNode): TypeOperatorNode;
(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword, type: TypeNode): TypeOperatorNode;
};
/** @deprecated Use `factory.createTaggedTemplate` or the factory supplied by your transformation context instead. */
const createTaggedTemplate: {
(tag: Expression, template: TemplateLiteral): TaggedTemplateExpression;
(tag: Expression, typeArguments: readonly TypeNode[] | undefined, template: TemplateLiteral): TaggedTemplateExpression;
};
/** @deprecated Use `factory.updateTaggedTemplate` or the factory supplied by your transformation context instead. */
const updateTaggedTemplate: {
(node: TaggedTemplateExpression, tag: Expression, template: TemplateLiteral): TaggedTemplateExpression;
(node: TaggedTemplateExpression, tag: Expression, typeArguments: readonly TypeNode[] | undefined, template: TemplateLiteral): TaggedTemplateExpression;
};
/** @deprecated Use `factory.updateBinary` or the factory supplied by your transformation context instead. */
const updateBinary: (node: BinaryExpression, left: Expression, right: Expression, operator?: BinaryOperator | BinaryOperatorToken) => BinaryExpression;
/** @deprecated Use `factory.createConditional` or the factory supplied by your transformation context instead. */
const createConditional: {
(condition: Expression, whenTrue: Expression, whenFalse: Expression): ConditionalExpression;
(condition: Expression, questionToken: QuestionToken, whenTrue: Expression, colonToken: ColonToken, whenFalse: Expression): ConditionalExpression;
};
/** @deprecated Use `factory.createYield` or the factory supplied by your transformation context instead. */
const createYield: {
(expression?: Expression | undefined): YieldExpression;
(asteriskToken: AsteriskToken | undefined, expression: Expression): YieldExpression;
};
/** @deprecated Use `factory.createClassExpression` or the factory supplied by your transformation context instead. */
const createClassExpression: (modifiers: readonly Modifier[] | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]) => ClassExpression;
/** @deprecated Use `factory.updateClassExpression` or the factory supplied by your transformation context instead. */
const updateClassExpression: (node: ClassExpression, modifiers: readonly Modifier[] | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]) => ClassExpression;
/** @deprecated Use `factory.createPropertySignature` or the factory supplied by your transformation context instead. */
const createPropertySignature: (modifiers: readonly Modifier[] | undefined, name: PropertyName | string, questionToken: QuestionToken | undefined, type: TypeNode | undefined, initializer?: Expression | undefined) => PropertySignature;
/** @deprecated Use `factory.updatePropertySignature` or the factory supplied by your transformation context instead. */
const updatePropertySignature: (node: PropertySignature, modifiers: readonly Modifier[] | undefined, name: PropertyName, questionToken: QuestionToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined) => PropertySignature;
/** @deprecated Use `factory.createExpressionWithTypeArguments` or the factory supplied by your transformation context instead. */
const createExpressionWithTypeArguments: (typeArguments: readonly TypeNode[] | undefined, expression: Expression) => ExpressionWithTypeArguments;
/** @deprecated Use `factory.updateExpressionWithTypeArguments` or the factory supplied by your transformation context instead. */
const updateExpressionWithTypeArguments: (node: ExpressionWithTypeArguments, typeArguments: readonly TypeNode[] | undefined, expression: Expression) => ExpressionWithTypeArguments;
/** @deprecated Use `factory.createArrowFunction` or the factory supplied by your transformation context instead. */
const createArrowFunction: {
(modifiers: readonly Modifier[] | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, equalsGreaterThanToken: EqualsGreaterThanToken | undefined, body: ConciseBody): ArrowFunction;
(modifiers: readonly Modifier[] | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: ConciseBody): ArrowFunction;
};
/** @deprecated Use `factory.updateArrowFunction` or the factory supplied by your transformation context instead. */
const updateArrowFunction: {
(node: ArrowFunction, modifiers: readonly Modifier[] | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, equalsGreaterThanToken: EqualsGreaterThanToken, body: ConciseBody): ArrowFunction;
(node: ArrowFunction, modifiers: readonly Modifier[] | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: ConciseBody): ArrowFunction;
};
/** @deprecated Use `factory.createVariableDeclaration` or the factory supplied by your transformation context instead. */
const createVariableDeclaration: {
(name: string | BindingName, type?: TypeNode | undefined, initializer?: Expression | undefined): VariableDeclaration;
(name: string | BindingName, exclamationToken: ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): VariableDeclaration;
};
/** @deprecated Use `factory.updateVariableDeclaration` or the factory supplied by your transformation context instead. */
const updateVariableDeclaration: {
(node: VariableDeclaration, name: BindingName, type: TypeNode | undefined, initializer: Expression | undefined): VariableDeclaration;
(node: VariableDeclaration, name: BindingName, exclamationToken: ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): VariableDeclaration;
};
/** @deprecated Use `factory.createImportClause` or the factory supplied by your transformation context instead. */
const createImportClause: (name: Identifier | undefined, namedBindings: NamedImportBindings | undefined, isTypeOnly?: any) => ImportClause;
/** @deprecated Use `factory.updateImportClause` or the factory supplied by your transformation context instead. */
const updateImportClause: (node: ImportClause, name: Identifier | undefined, namedBindings: NamedImportBindings | undefined, isTypeOnly: boolean) => ImportClause;
/** @deprecated Use `factory.createExportDeclaration` or the factory supplied by your transformation context instead. */
const createExportDeclaration: (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, exportClause: NamedExportBindings | undefined, moduleSpecifier?: Expression | undefined, isTypeOnly?: any) => ExportDeclaration;
/** @deprecated Use `factory.updateExportDeclaration` or the factory supplied by your transformation context instead. */
const updateExportDeclaration: (node: ExportDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, exportClause: NamedExportBindings | undefined, moduleSpecifier: Expression | undefined, isTypeOnly: boolean) => ExportDeclaration;
/** @deprecated Use `factory.createJSDocParameterTag` or the factory supplied by your transformation context instead. */
const createJSDocParamTag: (name: EntityName, isBracketed: boolean, typeExpression?: JSDocTypeExpression | undefined, comment?: string | undefined) => JSDocParameterTag;
/** @deprecated Use `factory.createComma` or the factory supplied by your transformation context instead. */
const createComma: (left: Expression, right: Expression) => Expression;
/** @deprecated Use `factory.createLessThan` or the factory supplied by your transformation context instead. */
const createLessThan: (left: Expression, right: Expression) => Expression;
/** @deprecated Use `factory.createAssignment` or the factory supplied by your transformation context instead. */
const createAssignment: (left: Expression, right: Expression) => BinaryExpression;
/** @deprecated Use `factory.createStrictEquality` or the factory supplied by your transformation context instead. */
const createStrictEquality: (left: Expression, right: Expression) => BinaryExpression;
/** @deprecated Use `factory.createStrictInequality` or the factory supplied by your transformation context instead. */
const createStrictInequality: (left: Expression, right: Expression) => BinaryExpression;
/** @deprecated Use `factory.createAdd` or the factory supplied by your transformation context instead. */
const createAdd: (left: Expression, right: Expression) => BinaryExpression;
/** @deprecated Use `factory.createSubtract` or the factory supplied by your transformation context instead. */
const createSubtract: (left: Expression, right: Expression) => BinaryExpression;
/** @deprecated Use `factory.createLogicalAnd` or the factory supplied by your transformation context instead. */
const createLogicalAnd: (left: Expression, right: Expression) => BinaryExpression;
/** @deprecated Use `factory.createLogicalOr` or the factory supplied by your transformation context instead. */
const createLogicalOr: (left: Expression, right: Expression) => BinaryExpression;
/** @deprecated Use `factory.createPostfixIncrement` or the factory supplied by your transformation context instead. */
const createPostfixIncrement: (operand: Expression) => PostfixUnaryExpression;
/** @deprecated Use `factory.createLogicalNot` or the factory supplied by your transformation context instead. */
const createLogicalNot: (operand: Expression) => PrefixUnaryExpression;
/** @deprecated Use an appropriate `factory` method instead. */
const createNode: (kind: SyntaxKind, pos?: any, end?: any) => Node;
/**
* Creates a shallow, memberwise clone of a node ~for mutation~ with its `pos`, `end`, and `parent` set.
*
* NOTE: It is unsafe to change any properties of a `Node` that relate to its AST children, as those changes won't be
* captured with respect to transformations.
*
* @deprecated Use an appropriate `factory.update...` method instead, use `setCommentRange` or `setSourceMapRange`, and avoid setting `parent`.
*/
const getMutableClone: <T extends Node>(node: T) => T;
/** @deprecated Use `isTypeAssertionExpression` instead. */
const isTypeAssertion: (node: Node) => node is TypeAssertion;
/**
* @deprecated Use `isMemberName` instead.
*/
const isIdentifierOrPrivateIdentifier: (node: Node) => node is MemberName;
}
export = ts;