@tslite/parser 1.10.0 → 1.13.0

package/dist/factoryPublic.d.ts

@@ -0,0 +1,314 @@
+import { EmitFlags, GeneratedIdentifierFlags, ModifierFlags, NodeFlags, SyntaxKind, TokenFlags } from "./_namespaces/ts.js";
+import type { ArrayBindingElement, ArrayBindingPattern, ArrayLiteralExpression, ArrayTypeNode, ArrowFunction, AsExpression, AssertsToken, AwaitExpression, AwaitKeywordToken, BigIntLiteral, BinaryExpression, BinaryOperator, BinaryOperatorToken, BindingElement, BindingName, Block, BooleanLiteral, BreakStatement, Bundle, CallChain, CallExpression, CallSignatureDeclaration, CaseBlock, CaseClause, CaseOrDefaultClause, CatchClause, ColonToken, CommaListExpression, ComputedPropertyName, ConciseBody, ConditionalExpression, ConditionalTypeNode, ContinueStatement, DefaultClause, DeleteExpression, DestructuringAssignment, DoStatement, DotDotDotToken, ElementAccessChain, ElementAccessExpression, EmitHelper, EmitNode, EmptyStatement, EntityName, EqualsGreaterThanToken, ExportAssignment, ExportDeclaration, ExportSpecifier, Expression, ExpressionStatement, ForInStatement, ForInitializer, ForOfStatement, ForStatement, FunctionLikeDeclaration, FunctionTypeNode, GeneratedIdentifier, Identifier, IfStatement, ImportClause, ImportDeclaration, ImportSpecifier, ImportTypeNode, IndexSignatureDeclaration, IndexedAccessTypeNode, InferTypeNode, InputFiles, IntersectionTypeNode, JsxAttribute, JsxAttributeLike, JsxAttributes, JsxChild, JsxClosingElement, JsxClosingFragment, JsxElement, JsxExpression, JsxFragment, JsxText, JsxOpeningElement, JsxOpeningFragment, JsxSelfClosingElement, JsxSpreadAttribute, JsxTagNameExpression, KeywordTypeNode, LiteralTypeNode, MappedTypeNode, MetaProperty, MethodSignature, MinusToken, Modifier, ModuleBlock, ModuleBody, ModuleDeclaration, ModuleName, MutableNodeArray, NamedExportBindings, NamedExports, NamedImportBindings, NamedImports, NamespaceExport, NamespaceImport, NoSubstitutionTemplateLiteral, OmittedExpression, Node, NodeArray, NumericLiteral, ObjectBindingPattern, ObjectLiteralElementLike, ObjectLiteralExpression, OptionalTypeNode, ParameterDeclaration, ParenthesizedExpression, ParenthesizedTypeNode, PartiallyEmittedExpression, PlusToken, PostfixUnaryExpression, PostfixUnaryOperator, PrefixUnaryExpression, PrefixUnaryOperator, PrimaryExpression, PropertyAccessChain, PropertyAccessExpression, PropertyAssignment, PropertyName, PropertySignature, PseudoBigInt, QualifiedName, QuestionDotToken, QuestionToken, ReadonlyToken, RestTypeNode, ReturnStatement, ShorthandPropertyAssignment, SignatureDeclaration, SourceFile, SourceMapRange, SpreadAssignment, SpreadElement, Statement, StringLiteral, SwitchStatement, SynthesizedComment, TemplateExpression, TemplateHead, TemplateMiddle, TemplateSpan, TemplateTail, TextRange, ThrowStatement, Token, TryStatement, TupleTypeNode, TypeAliasDeclaration, TypeElement, TypeLiteralNode, TypeNode, TypeOfExpression, TypeOperatorNode, TypeParameterDeclaration, TypePredicateNode, TypeQueryNode, TypeReferenceNode, UnionTypeNode, UnparsedSource, VariableDeclaration, VariableDeclarationList, VariableStatement, WhileStatement } from "./_namespaces/ts.js";
+export declare function updateNode<T extends Node>(updated: T, original: T): T;
+export declare function createNodeArray<T extends Node>(elements?: T[], hasTrailingComma?: boolean): MutableNodeArray<T>;
+export declare function createNodeArray<T extends Node>(elements?: readonly T[], hasTrailingComma?: boolean): NodeArray<T>;
+/**
+ * Creates a shallow, memberwise clone of a node with no source map location.
+ */
+export declare function getSynthesizedClone<T extends Node>(node: T): T;
+export declare function createLiteral(value: string | StringLiteral | NoSubstitutionTemplateLiteral | NumericLiteral | Identifier, isSingleQuote: boolean): StringLiteral;
+export declare function createLiteral(value: string | number, isSingleQuote: boolean): StringLiteral | NumericLiteral;
+/** If a node is passed, creates a string literal whose source text is read from a source node during emit. */
+export declare function createLiteral(value: string | StringLiteral | NoSubstitutionTemplateLiteral | NumericLiteral | Identifier): StringLiteral;
+export declare function createLiteral(value: number | PseudoBigInt): NumericLiteral;
+export declare function createLiteral(value: boolean): BooleanLiteral;
+export declare function createLiteral(value: string | number | PseudoBigInt | boolean): PrimaryExpression;
+export declare function createNumericLiteral(value: string, numericLiteralFlags?: TokenFlags): NumericLiteral;
+export declare function createBigIntLiteral(value: string): BigIntLiteral;
+export declare function createStringLiteral(text: string): StringLiteral;
+export declare function createIdentifier(text: string): Identifier;
+export declare function createIdentifier(text: string, typeArguments: readonly (TypeNode | TypeParameterDeclaration)[] | undefined): Identifier;
+export declare function updateIdentifier(node: Identifier): Identifier;
+export declare function updateIdentifier(node: Identifier, typeArguments: NodeArray<TypeNode | TypeParameterDeclaration> | undefined): Identifier;
+export declare function createOptimisticUniqueName(text: string): GeneratedIdentifier;
+/** Create a unique name based on the supplied text. */
+export declare function createOptimisticUniqueName(text: string): Identifier;
+/** Create a unique name generated for a node. */
+export declare function getGeneratedNameForNode(node: Node | undefined): Identifier;
+export declare function getGeneratedNameForNode(node: Node | undefined, flags: GeneratedIdentifierFlags): Identifier;
+export declare function createToken<TKind extends SyntaxKind>(token: TKind): Token<TKind>;
+export declare function createTrue(): BooleanLiteral & Token<SyntaxKind.TrueKeyword>;
+export declare function createFalse(): BooleanLiteral & Token<SyntaxKind.FalseKeyword>;
+export declare function createModifier<T extends Modifier["kind"]>(kind: T): Token<T>;
+/** Na tag, também o `default`, o `const` de um enum e os modificadores de classe (CK-02). */
+export declare function createModifiersFromModifierFlags(flags: ModifierFlags): Modifier[];
+export declare function createQualifiedName(left: EntityName, right: string | Identifier): QualifiedName;
+export declare function updateQualifiedName(node: QualifiedName, left: EntityName, right: Identifier): QualifiedName;
+export declare function createComputedPropertyName(expression: Expression): ComputedPropertyName;
+export declare function updateComputedPropertyName(node: ComputedPropertyName, expression: Expression): ComputedPropertyName;
+export declare function createTypeParameterDeclaration(name: string | Identifier, constraint?: TypeNode, defaultType?: TypeNode): TypeParameterDeclaration;
+export declare function updateTypeParameterDeclaration(node: TypeParameterDeclaration, name: Identifier, constraint: TypeNode | undefined, defaultType: TypeNode | undefined): TypeParameterDeclaration;
+export declare function createParameter(modifiers: readonly Modifier[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | BindingName, questionToken?: QuestionToken, type?: TypeNode, initializer?: Expression): ParameterDeclaration;
+export declare function updateParameter(node: ParameterDeclaration, modifiers: readonly Modifier[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | BindingName, questionToken: QuestionToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): ParameterDeclaration;
+export declare function createPropertySignature(modifiers: readonly Modifier[] | undefined, name: PropertyName | string, questionToken: QuestionToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): PropertySignature;
+export declare function updatePropertySignature(node: PropertySignature, modifiers: readonly Modifier[] | undefined, name: PropertyName, questionToken: QuestionToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): PropertySignature;
+export declare function createMethodSignature(typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, name: string | PropertyName, questionToken: QuestionToken | undefined): MethodSignature;
+export declare function updateMethodSignature(node: MethodSignature, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode | undefined, name: PropertyName, questionToken: QuestionToken | undefined): MethodSignature;
+export declare function updateCallSignature(node: CallSignatureDeclaration, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode | undefined): CallSignatureDeclaration;
+export declare function createIndexSignature(modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): IndexSignatureDeclaration;
+export declare function updateIndexSignature(node: IndexSignatureDeclaration, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): IndexSignatureDeclaration;
+export declare function createSignatureDeclaration(kind: SyntaxKind, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, typeArguments?: readonly TypeNode[] | undefined): SignatureDeclaration;
+export declare function createKeywordTypeNode(kind: KeywordTypeNode["kind"]): KeywordTypeNode;
+export declare function createTypePredicateNodeWithModifier(assertsModifier: AssertsToken | undefined, parameterName: Identifier | string, type: TypeNode | undefined): TypePredicateNode;
+export declare function updateTypePredicateNodeWithModifier(node: TypePredicateNode, assertsModifier: AssertsToken | undefined, parameterName: Identifier, type: TypeNode | undefined): TypePredicateNode;
+export declare function createTypeReferenceNode(typeName: string | EntityName, typeArguments: readonly TypeNode[] | undefined): TypeReferenceNode;
+export declare function updateTypeReferenceNode(node: TypeReferenceNode, typeName: EntityName, typeArguments: NodeArray<TypeNode> | undefined): TypeReferenceNode;
+export declare function createFunctionTypeNode(typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined): FunctionTypeNode;
+export declare function updateFunctionTypeNode(node: FunctionTypeNode, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode | undefined): FunctionTypeNode;
+export declare function createTypeQueryNode(exprName: EntityName): TypeQueryNode;
+export declare function updateTypeQueryNode(node: TypeQueryNode, exprName: EntityName): TypeQueryNode;
+export declare function createTypeLiteralNode(members: readonly TypeElement[] | undefined): TypeLiteralNode;
+export declare function updateTypeLiteralNode(node: TypeLiteralNode, members: NodeArray<TypeElement>): TypeLiteralNode;
+export declare function createArrayTypeNode(elementType: TypeNode): ArrayTypeNode;
+export declare function updateArrayTypeNode(node: ArrayTypeNode, elementType: TypeNode): ArrayTypeNode;
+export declare function createTupleTypeNode(elementTypes: readonly TypeNode[]): TupleTypeNode;
+export declare function updateTupleTypeNode(node: TupleTypeNode, elementTypes: readonly TypeNode[]): TupleTypeNode;
+export declare function createOptionalTypeNode(type: TypeNode): OptionalTypeNode;
+export declare function updateOptionalTypeNode(node: OptionalTypeNode, type: TypeNode): OptionalTypeNode;
+export declare function createRestTypeNode(type: TypeNode): RestTypeNode;
+export declare function updateRestTypeNode(node: RestTypeNode, type: TypeNode): RestTypeNode;
+export declare function createUnionTypeNode(types: readonly TypeNode[]): UnionTypeNode;
+export declare function updateUnionTypeNode(node: UnionTypeNode, types: NodeArray<TypeNode>): UnionTypeNode;
+export declare function createIntersectionTypeNode(types: readonly TypeNode[]): IntersectionTypeNode;
+export declare function updateIntersectionTypeNode(node: IntersectionTypeNode, types: NodeArray<TypeNode>): IntersectionTypeNode;
+export declare function createUnionOrIntersectionTypeNode(kind: SyntaxKind.UnionType | SyntaxKind.IntersectionType, types: readonly TypeNode[]): UnionTypeNode | IntersectionTypeNode;
+export declare function createConditionalTypeNode(checkType: TypeNode, extendsType: TypeNode, trueType: TypeNode, falseType: TypeNode): ConditionalTypeNode;
+export declare function updateConditionalTypeNode(node: ConditionalTypeNode, checkType: TypeNode, extendsType: TypeNode, trueType: TypeNode, falseType: TypeNode): ConditionalTypeNode;
+export declare function createInferTypeNode(typeParameter: TypeParameterDeclaration): InferTypeNode;
+export declare function updateInferTypeNode(node: InferTypeNode, typeParameter: TypeParameterDeclaration): InferTypeNode;
+export declare function createImportTypeNode(argument: TypeNode, qualifier?: EntityName, typeArguments?: readonly TypeNode[], isTypeOf?: boolean): ImportTypeNode;
+export declare function updateImportTypeNode(node: ImportTypeNode, argument: TypeNode, qualifier?: EntityName, typeArguments?: readonly TypeNode[], isTypeOf?: boolean): ImportTypeNode;
+export declare function createParenthesizedType(type: TypeNode): ParenthesizedTypeNode;
+export declare function updateParenthesizedType(node: ParenthesizedTypeNode, type: TypeNode): ParenthesizedTypeNode;
+export declare function createTypeOperatorNode(type: TypeNode): TypeOperatorNode;
+export declare function createTypeOperatorNode(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.ReadonlyKeyword, type: TypeNode): TypeOperatorNode;
+export declare function updateTypeOperatorNode(node: TypeOperatorNode, type: TypeNode): TypeOperatorNode;
+export declare function createIndexedAccessTypeNode(objectType: TypeNode, indexType: TypeNode): IndexedAccessTypeNode;
+export declare function updateIndexedAccessTypeNode(node: IndexedAccessTypeNode, objectType: TypeNode, indexType: TypeNode): IndexedAccessTypeNode;
+export declare function createMappedTypeNode(readonlyToken: ReadonlyToken | PlusToken | MinusToken | undefined, typeParameter: TypeParameterDeclaration, questionToken: QuestionToken | PlusToken | MinusToken | undefined, type: TypeNode | undefined): MappedTypeNode;
+export declare function updateMappedTypeNode(node: MappedTypeNode, readonlyToken: ReadonlyToken | PlusToken | MinusToken | undefined, typeParameter: TypeParameterDeclaration, questionToken: QuestionToken | PlusToken | MinusToken | undefined, type: TypeNode | undefined): MappedTypeNode;
+export declare function createLiteralTypeNode(literal: LiteralTypeNode["literal"]): LiteralTypeNode;
+export declare function updateLiteralTypeNode(node: LiteralTypeNode, literal: LiteralTypeNode["literal"]): LiteralTypeNode;
+export declare function createObjectBindingPattern(elements: readonly BindingElement[]): ObjectBindingPattern;
+export declare function updateObjectBindingPattern(node: ObjectBindingPattern, elements: readonly BindingElement[]): ObjectBindingPattern;
+export declare function createArrayBindingPattern(elements: readonly ArrayBindingElement[]): ArrayBindingPattern;
+export declare function updateArrayBindingPattern(node: ArrayBindingPattern, elements: readonly ArrayBindingElement[]): ArrayBindingPattern;
+export declare function createBindingElement(dotDotDotToken: DotDotDotToken | undefined, propertyName: string | PropertyName | undefined, name: string | BindingName, initializer?: Expression): BindingElement;
+export declare function updateBindingElement(node: BindingElement, dotDotDotToken: DotDotDotToken | undefined, propertyName: PropertyName | undefined, name: BindingName, initializer: Expression | undefined): BindingElement;
+export declare function createArrayLiteral(elements?: readonly Expression[], multiLine?: boolean): ArrayLiteralExpression;
+export declare function updateArrayLiteral(node: ArrayLiteralExpression, elements: readonly Expression[]): ArrayLiteralExpression;
+export declare function createObjectLiteral(properties?: readonly ObjectLiteralElementLike[], multiLine?: boolean): ObjectLiteralExpression;
+export declare function updateObjectLiteral(node: ObjectLiteralExpression, properties: readonly ObjectLiteralElementLike[]): ObjectLiteralExpression;
+export declare function createPropertyAccess(expression: Expression, name: string | Identifier): PropertyAccessExpression;
+export declare function updatePropertyAccess(node: PropertyAccessExpression, expression: Expression, name: Identifier): PropertyAccessExpression;
+export declare function createPropertyAccessChain(expression: Expression, questionDotToken: QuestionDotToken | undefined, name: string | Identifier): PropertyAccessChain;
+export declare function updatePropertyAccessChain(node: PropertyAccessChain, expression: Expression, questionDotToken: QuestionDotToken | undefined, name: Identifier): PropertyAccessChain;
+export declare function createElementAccess(expression: Expression, index: number | Expression): ElementAccessExpression;
+export declare function updateElementAccess(node: ElementAccessExpression, expression: Expression, argumentExpression: Expression): ElementAccessExpression;
+export declare function createElementAccessChain(expression: Expression, questionDotToken: QuestionDotToken | undefined, index: number | Expression): ElementAccessChain;
+export declare function updateElementAccessChain(node: ElementAccessChain, expression: Expression, questionDotToken: QuestionDotToken | undefined, argumentExpression: Expression): ElementAccessChain;
+export declare function createCall(expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined): CallExpression;
+export declare function updateCall(node: CallExpression, expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[]): CallExpression;
+export declare function createCallChain(expression: Expression, questionDotToken: QuestionDotToken | undefined, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined): CallChain;
+export declare function updateCallChain(node: CallChain, expression: Expression, questionDotToken: QuestionDotToken | undefined, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[]): CallChain;
+export declare function createParen(expression: Expression): ParenthesizedExpression;
+export declare function updateParen(node: ParenthesizedExpression, expression: Expression): ParenthesizedExpression;
+export declare function createArrowFunction(modifiers: readonly Modifier[] | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, equalsGreaterThanToken: EqualsGreaterThanToken | undefined, body: ConciseBody): ArrowFunction;
+export declare function updateArrowFunction(node: ArrowFunction, modifiers: readonly Modifier[] | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, equalsGreaterThanToken: Token<SyntaxKind.EqualsGreaterThanToken>, body: ConciseBody): ArrowFunction;
+export declare function createDelete(expression: Expression): DeleteExpression;
+export declare function updateDelete(node: DeleteExpression, expression: Expression): DeleteExpression;
+export declare function createTypeOf(expression: Expression): TypeOfExpression;
+export declare function updateTypeOf(node: TypeOfExpression, expression: Expression): TypeOfExpression;
+export declare function createAwait(expression: Expression): AwaitExpression;
+export declare function updateAwait(node: AwaitExpression, expression: Expression): AwaitExpression;
+export declare function createPrefix(operator: PrefixUnaryOperator, operand: Expression): PrefixUnaryExpression;
+export declare function updatePrefix(node: PrefixUnaryExpression, operand: Expression): PrefixUnaryExpression;
+export declare function createPostfix(operand: Expression, operator: PostfixUnaryOperator): PostfixUnaryExpression;
+export declare function updatePostfix(node: PostfixUnaryExpression, operand: Expression): PostfixUnaryExpression;
+export declare function createBinary(left: Expression, operator: BinaryOperator | BinaryOperatorToken, right: Expression): BinaryExpression;
+export declare function updateBinary(node: BinaryExpression, left: Expression, right: Expression, operator?: BinaryOperator | BinaryOperatorToken): BinaryExpression;
+/** @deprecated */ export declare function createConditional(condition: Expression, whenTrue: Expression, whenFalse: Expression): ConditionalExpression;
+export declare function createConditional(condition: Expression, questionToken: QuestionToken, whenTrue: Expression, colonToken: ColonToken, whenFalse: Expression): ConditionalExpression;
+export declare function updateConditional(node: ConditionalExpression, condition: Expression, questionToken: Token<SyntaxKind.QuestionToken>, whenTrue: Expression, colonToken: Token<SyntaxKind.ColonToken>, whenFalse: Expression): ConditionalExpression;
+export declare function createTemplateExpression(head: TemplateHead, templateSpans: readonly TemplateSpan[]): TemplateExpression;
+export declare function updateTemplateExpression(node: TemplateExpression, head: TemplateHead, templateSpans: readonly TemplateSpan[]): TemplateExpression;
+export declare function createTemplateHead(text: string, rawText?: string): TemplateHead;
+export declare function createTemplateMiddle(text: string, rawText?: string): TemplateMiddle;
+export declare function createTemplateTail(text: string, rawText?: string): TemplateTail;
+export declare function createNoSubstitutionTemplateLiteral(text: string, rawText?: string): NoSubstitutionTemplateLiteral;
+export declare function createSpread(expression: Expression): SpreadElement;
+export declare function updateSpread(node: SpreadElement, expression: Expression): SpreadElement;
+export declare function createOmittedExpression(): OmittedExpression;
+export declare function createAsExpression(expression: Expression, type: TypeNode): AsExpression;
+export declare function updateAsExpression(node: AsExpression, expression: Expression, type: TypeNode): AsExpression;
+export declare function createMetaProperty(keywordToken: MetaProperty["keywordToken"], name: Identifier): MetaProperty;
+export declare function updateMetaProperty(node: MetaProperty, name: Identifier): MetaProperty;
+export declare function createTemplateSpan(expression: Expression, literal: TemplateMiddle | TemplateTail): TemplateSpan;
+export declare function updateTemplateSpan(node: TemplateSpan, expression: Expression, literal: TemplateMiddle | TemplateTail): TemplateSpan;
+export declare function createBlock(statements: readonly Statement[], multiLine?: boolean): Block;
+export declare function updateBlock(node: Block, statements: readonly Statement[]): Block;
+export declare function createVariableStatement(modifiers: readonly Modifier[] | undefined, declarationList: VariableDeclarationList | readonly VariableDeclaration[]): VariableStatement;
+export declare function updateVariableStatement(node: VariableStatement, modifiers: readonly Modifier[] | undefined, declarationList: VariableDeclarationList): VariableStatement;
+export declare function createEmptyStatement(): EmptyStatement;
+export declare function createExpressionStatement(expression: Expression): ExpressionStatement;
+export declare function updateExpressionStatement(node: ExpressionStatement, expression: Expression): ExpressionStatement;
+/** @deprecated Use `createExpressionStatement` instead.  */
+export declare const createStatement: typeof createExpressionStatement;
+export declare function createIf(expression: Expression, thenStatement: Statement, elseStatement?: Statement): IfStatement;
+export declare function updateIf(node: IfStatement, expression: Expression, thenStatement: Statement, elseStatement: Statement | undefined): IfStatement;
+export declare function createDo(statement: Statement, expression: Expression): DoStatement;
+export declare function updateDo(node: DoStatement, statement: Statement, expression: Expression): DoStatement;
+export declare function createWhile(expression: Expression, statement: Statement): WhileStatement;
+export declare function updateWhile(node: WhileStatement, expression: Expression, statement: Statement): WhileStatement;
+export declare function createFor(initializer: ForInitializer | undefined, condition: Expression | undefined, incrementor: Expression | undefined, statement: Statement): ForStatement;
+export declare function updateFor(node: ForStatement, initializer: ForInitializer | undefined, condition: Expression | undefined, incrementor: Expression | undefined, statement: Statement): ForStatement;
+export declare function createForIn(initializer: ForInitializer, expression: Expression, statement: Statement): ForInStatement;
+export declare function updateForIn(node: ForInStatement, initializer: ForInitializer, expression: Expression, statement: Statement): ForInStatement;
+export declare function createForOf(awaitModifier: AwaitKeywordToken | undefined, initializer: ForInitializer, expression: Expression, statement: Statement): ForOfStatement;
+export declare function updateForOf(node: ForOfStatement, awaitModifier: AwaitKeywordToken | undefined, initializer: ForInitializer, expression: Expression, statement: Statement): ForOfStatement;
+export declare function createContinue(): ContinueStatement;
+export declare function createBreak(): BreakStatement;
+export declare function createReturn(expression?: Expression): ReturnStatement;
+export declare function updateReturn(node: ReturnStatement, expression: Expression | undefined): ReturnStatement;
+export declare function createSwitch(expression: Expression, caseBlock: CaseBlock): SwitchStatement;
+export declare function updateSwitch(node: SwitchStatement, expression: Expression, caseBlock: CaseBlock): SwitchStatement;
+export declare function createThrow(expression: Expression): ThrowStatement;
+export declare function updateThrow(node: ThrowStatement, expression: Expression): ThrowStatement;
+export declare function createTry(tryBlock: Block, catchClause: CatchClause | undefined, finallyBlock: Block | undefined): TryStatement;
+export declare function updateTry(node: TryStatement, tryBlock: Block, catchClause: CatchClause | undefined, finallyBlock: Block | undefined): TryStatement;
+export declare function createVariableDeclaration(name: string | BindingName, type?: TypeNode, initializer?: Expression): VariableDeclaration;
+export declare function createTypeScriptVariableDeclaration(name: string | BindingName, exclaimationToken?: Token<SyntaxKind.ExclamationToken>, type?: TypeNode, initializer?: Expression): VariableDeclaration;
+export declare function updateTypeScriptVariableDeclaration(node: VariableDeclaration, name: BindingName, exclaimationToken: Token<SyntaxKind.ExclamationToken> | undefined, type: TypeNode | undefined, initializer: Expression | undefined): VariableDeclaration;
+export declare function createVariableDeclarationList(declarations: readonly VariableDeclaration[], flags?: NodeFlags): VariableDeclarationList;
+export declare function updateVariableDeclarationList(node: VariableDeclarationList, declarations: readonly VariableDeclaration[]): VariableDeclarationList;
+/** A função com outro corpo. Na tag, também a `function`, o método, o acessor e o construtor (CK-02). */
+export declare function updateFunctionLikeBody(declaration: FunctionLikeDeclaration, body: Block): FunctionLikeDeclaration;
+export declare function createTypeAliasDeclaration(modifiers: readonly Modifier[] | undefined, name: string | Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, type: TypeNode): TypeAliasDeclaration;
+export declare function updateTypeAliasDeclaration(node: TypeAliasDeclaration, modifiers: readonly Modifier[] | undefined, name: Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, type: TypeNode): TypeAliasDeclaration;
+export declare function createModuleDeclaration(modifiers: readonly Modifier[] | undefined, name: ModuleName, body: ModuleBody | undefined, flags?: NodeFlags): ModuleDeclaration;
+export declare function updateModuleDeclaration(node: ModuleDeclaration, modifiers: readonly Modifier[] | undefined, name: ModuleName, body: ModuleBody | undefined): ModuleDeclaration;
+export declare function createModuleBlock(statements: readonly Statement[]): ModuleBlock;
+export declare function updateModuleBlock(node: ModuleBlock, statements: readonly Statement[]): ModuleBlock;
+export declare function createCaseBlock(clauses: readonly CaseOrDefaultClause[]): CaseBlock;
+export declare function updateCaseBlock(node: CaseBlock, clauses: readonly CaseOrDefaultClause[]): CaseBlock;
+export declare function createImportDeclaration(modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression): ImportDeclaration;
+export declare function updateImportDeclaration(node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression): ImportDeclaration;
+export declare function createImportClause(name: Identifier | undefined, namedBindings: NamedImportBindings | undefined, isTypeOnly?: boolean): ImportClause;
+export declare function updateImportClause(node: ImportClause, name: Identifier | undefined, namedBindings: NamedImportBindings | undefined, isTypeOnly: boolean): ImportClause;
+export declare function createNamespaceImport(name: Identifier): NamespaceImport;
+export declare function createNamespaceExport(name: Identifier): NamespaceExport;
+export declare function updateNamespaceImport(node: NamespaceImport, name: Identifier): NamespaceImport;
+export declare function updateNamespaceExport(node: NamespaceExport, name: Identifier): NamespaceExport;
+export declare function createNamedImports(elements: readonly ImportSpecifier[]): NamedImports;
+export declare function updateNamedImports(node: NamedImports, elements: readonly ImportSpecifier[]): NamedImports;
+export declare function createImportSpecifier(propertyName: Identifier | undefined, name: Identifier): ImportSpecifier;
+export declare function updateImportSpecifier(node: ImportSpecifier, propertyName: Identifier | undefined, name: Identifier): ImportSpecifier;
+export declare function createExportAssignment(modifiers: readonly Modifier[] | undefined, expression: Expression): ExportAssignment;
+export declare function updateExportAssignment(node: ExportAssignment, modifiers: readonly Modifier[] | undefined, expression: Expression): ExportAssignment;
+export declare function createExportDeclaration(modifiers: readonly Modifier[] | undefined, exportClause: NamedExportBindings | undefined, moduleSpecifier?: Expression, isTypeOnly?: boolean): ExportDeclaration;
+export declare function updateExportDeclaration(node: ExportDeclaration, modifiers: readonly Modifier[] | undefined, exportClause: NamedExportBindings | undefined, moduleSpecifier: Expression | undefined, isTypeOnly: boolean): ExportDeclaration;
+export declare function createNamedExports(elements: readonly ExportSpecifier[]): NamedExports;
+export declare function updateNamedExports(node: NamedExports, elements: readonly ExportSpecifier[]): NamedExports;
+export declare function createExportSpecifier(propertyName: string | Identifier | undefined, name: string | Identifier): ExportSpecifier;
+export declare function updateExportSpecifier(node: ExportSpecifier, propertyName: Identifier | undefined, name: Identifier): ExportSpecifier;
+export declare function createJsxElement(openingElement: JsxOpeningElement, children: readonly JsxChild[], closingElement: JsxClosingElement): JsxElement;
+export declare function updateJsxElement(node: JsxElement, openingElement: JsxOpeningElement, children: readonly JsxChild[], closingElement: JsxClosingElement): JsxElement;
+export declare function createJsxSelfClosingElement(tagName: JsxTagNameExpression, typeArguments: readonly TypeNode[] | undefined, attributes: JsxAttributes): JsxSelfClosingElement;
+export declare function updateJsxSelfClosingElement(node: JsxSelfClosingElement, tagName: JsxTagNameExpression, typeArguments: readonly TypeNode[] | undefined, attributes: JsxAttributes): JsxSelfClosingElement;
+export declare function createJsxOpeningElement(tagName: JsxTagNameExpression, typeArguments: readonly TypeNode[] | undefined, attributes: JsxAttributes): JsxOpeningElement;
+export declare function updateJsxOpeningElement(node: JsxOpeningElement, tagName: JsxTagNameExpression, typeArguments: readonly TypeNode[] | undefined, attributes: JsxAttributes): JsxOpeningElement;
+export declare function createJsxClosingElement(tagName: JsxTagNameExpression): JsxClosingElement;
+export declare function updateJsxClosingElement(node: JsxClosingElement, tagName: JsxTagNameExpression): JsxClosingElement;
+export declare function createJsxFragment(openingFragment: JsxOpeningFragment, children: readonly JsxChild[], closingFragment: JsxClosingFragment): JsxFragment;
+export declare function createJsxText(text: string, containsOnlyTriviaWhiteSpaces?: boolean): JsxText;
+export declare function createJsxOpeningFragment(): JsxOpeningFragment;
+export declare function createJsxJsxClosingFragment(): JsxClosingFragment;
+export declare function updateJsxFragment(node: JsxFragment, openingFragment: JsxOpeningFragment, children: readonly JsxChild[], closingFragment: JsxClosingFragment): JsxFragment;
+export declare function createJsxAttribute(name: Identifier, initializer: StringLiteral | JsxExpression): JsxAttribute;
+export declare function updateJsxAttribute(node: JsxAttribute, name: Identifier, initializer: StringLiteral | JsxExpression): JsxAttribute;
+export declare function createJsxAttributes(properties: readonly JsxAttributeLike[]): JsxAttributes;
+export declare function updateJsxAttributes(node: JsxAttributes, properties: readonly JsxAttributeLike[]): JsxAttributes;
+export declare function createJsxSpreadAttribute(expression: Expression): JsxSpreadAttribute;
+export declare function updateJsxSpreadAttribute(node: JsxSpreadAttribute, expression: Expression): JsxSpreadAttribute;
+export declare function createJsxExpression(dotDotDotToken: DotDotDotToken | undefined, expression: Expression | undefined): JsxExpression;
+export declare function updateJsxExpression(node: JsxExpression, expression: Expression | undefined): JsxExpression;
+export declare function createCaseClause(expression: Expression, statements: readonly Statement[]): CaseClause;
+export declare function updateCaseClause(node: CaseClause, expression: Expression, statements: readonly Statement[]): CaseClause;
+export declare function createDefaultClause(statements: readonly Statement[]): DefaultClause;
+export declare function updateDefaultClause(node: DefaultClause, statements: readonly Statement[]): DefaultClause;
+export declare function createCatchClause(variableDeclaration: string | VariableDeclaration | undefined, block: Block): CatchClause;
+export declare function updateCatchClause(node: CatchClause, variableDeclaration: VariableDeclaration | undefined, block: Block): CatchClause;
+export declare function createPropertyAssignment(name: string | PropertyName, initializer: Expression): PropertyAssignment;
+export declare function updatePropertyAssignment(node: PropertyAssignment, name: PropertyName, initializer: Expression): PropertyAssignment;
+export declare function createShorthandPropertyAssignment(name: string | Identifier, objectAssignmentInitializer?: Expression): ShorthandPropertyAssignment;
+export declare function updateShorthandPropertyAssignment(node: ShorthandPropertyAssignment, name: Identifier, objectAssignmentInitializer: Expression | undefined): ShorthandPropertyAssignment;
+export declare function createSpreadAssignment(expression: Expression): SpreadAssignment;
+export declare function updateSpreadAssignment(node: SpreadAssignment, expression: Expression): SpreadAssignment;
+export declare function updateSourceFileNode(node: SourceFile, statements: readonly Statement[], isDeclarationFile?: boolean, referencedFiles?: SourceFile["referencedFiles"], typeReferences?: SourceFile["typeReferenceDirectives"], hasNoDefaultLib?: boolean, libReferences?: SourceFile["libReferenceDirectives"]): SourceFile;
+/**
+ * Creates a shallow, memberwise clone of a node for mutation.
+ */
+export declare function getMutableClone<T extends Node>(node: T): T;
+/**
+ * Creates a synthetic expression to act as a placeholder for a not-emitted expression in
+ * order to preserve comments or sourcemap positions.
+ *
+ * @param expression The inner expression to emit.
+ * @param original The original outer expression.
+ * @param location The location for the expression. Defaults to the positions from "original" if provided.
+ */
+export declare function createPartiallyEmittedExpression(expression: Expression, original?: Node): PartiallyEmittedExpression;
+export declare function updatePartiallyEmittedExpression(node: PartiallyEmittedExpression, expression: Expression): PartiallyEmittedExpression;
+export declare function createCommaList(elements: readonly Expression[]): CommaListExpression;
+export declare function updateCommaList(node: CommaListExpression, elements: readonly Expression[]): CommaListExpression;
+export declare function createBundle(sourceFiles: readonly SourceFile[], prepends?: readonly (UnparsedSource | InputFiles)[]): Bundle;
+export declare function createAssignment(left: ObjectLiteralExpression | ArrayLiteralExpression, right: Expression): DestructuringAssignment;
+export declare function createAssignment(left: Expression, right: Expression): BinaryExpression;
+export declare function createExportDefault(expression: Expression): ExportAssignment;
+/**
+ * Associates a node with the current transformation, initializing
+ * various transient transformation properties.
+ */
+export declare function getOrCreateEmitNode(node: Node): EmitNode;
+export declare function setTextRange<T extends TextRange>(range: T, location: TextRange | undefined): T;
+/**
+ * Sets flags that control emit behavior of a node.
+ */
+export declare function setEmitFlags<T extends Node>(node: T, emitFlags: EmitFlags): T;
+/**
+ * Sets flags that control emit behavior of a node.
+ */
+export declare function addEmitFlags<T extends Node>(node: T, emitFlags: EmitFlags): T;
+/**
+ * Gets a custom text range to use when emitting source maps.
+ */
+export declare function getSourceMapRange(node: Node): SourceMapRange;
+/**
+ * Gets a custom text range to use when emitting comments.
+ */
+export declare function getStartsOnNewLine(node: Node): boolean | undefined;
+/**
+ * Sets a custom text range to use when emitting comments.
+ */
+export declare function setStartsOnNewLine<T extends Node>(node: T, newLine: boolean): T;
+/**
+ * Gets a custom text range to use when emitting comments.
+ */
+export declare function getCommentRange(node: Node): TextRange;
+/**
+ * Sets a custom text range to use when emitting comments.
+ */
+export declare function setCommentRange<T extends Node>(node: T, range: TextRange): T;
+export declare function getSyntheticLeadingComments(node: Node): SynthesizedComment[] | undefined;
+export declare function setSyntheticLeadingComments<T extends Node>(node: T, comments: SynthesizedComment[] | undefined): T;
+export declare function addSyntheticLeadingComment<T extends Node>(node: T, kind: SyntaxKind.SingleLineCommentTrivia | SyntaxKind.MultiLineCommentTrivia, text: string, hasTrailingNewLine?: boolean): T;
+export declare function getSyntheticTrailingComments(node: Node): SynthesizedComment[] | undefined;
+export declare function setSyntheticTrailingComments<T extends Node>(node: T, comments: SynthesizedComment[] | undefined): T;
+export declare function addSyntheticTrailingComment<T extends Node>(node: T, kind: SyntaxKind.SingleLineCommentTrivia | SyntaxKind.MultiLineCommentTrivia, text: string, hasTrailingNewLine?: boolean): T;
+export declare function ignoreSourceNewlines<T extends Node>(node: T): T;
+/**
+ * Gets the EmitHelpers of a node.
+ */
+export declare function getEmitHelpers(node: Node): EmitHelper[] | undefined;
+export declare function setOriginalNode<T extends Node>(node: T, original: Node | undefined): T;