hermes-transform 0.36.1 → 0.37.0

package/dist/generated/TransformReplaceSignatures.js.flow

@@ -17,7 +17,7 @@
 
 // lint directives to let us do some basic validation of generated files
 /* eslint no-undef: 'error', no-unused-vars: ['error', {vars: "local"}], no-redeclare: 'error' */
-/* global $NonMaybeType, Partial, $ReadOnly, $ReadOnlyArray, $FlowFixMe */
+/* global NonNullable, Partial, Readonly, ReadonlyArray, $FlowFixMe */
 
 'use strict';
 
@@ -234,1032 +234,1032 @@ import type {DetachedNode} from '../detachedNode';
 type AnyTypeAnnotationReplaceSignature = (
   target: AnyTypeAnnotation,
   nodeToReplaceWith: DetachedNode<AnyTypeAnnotation>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type ArrayExpressionReplaceSignature = (
   target: ArrayExpression,
   nodeToReplaceWith: DetachedNode<ArrayExpression>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type ArrayPatternReplaceSignature = (
   target: ArrayPattern,
   nodeToReplaceWith: DetachedNode<ArrayPattern>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type ArrayTypeAnnotationReplaceSignature = (
   target: ArrayTypeAnnotation,
   nodeToReplaceWith: DetachedNode<ArrayTypeAnnotation>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type ArrowFunctionExpressionReplaceSignature = (
   target: ArrowFunctionExpression,
   nodeToReplaceWith: DetachedNode<ArrowFunctionExpression>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type AsConstExpressionReplaceSignature = (
   target: AsConstExpression,
   nodeToReplaceWith: DetachedNode<AsConstExpression>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type AsExpressionReplaceSignature = (
   target: AsExpression,
   nodeToReplaceWith: DetachedNode<AsExpression>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type AssignmentExpressionReplaceSignature = (
   target: AssignmentExpression,
   nodeToReplaceWith: DetachedNode<AssignmentExpression>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type AssignmentPatternReplaceSignature = (
   target: AssignmentPattern,
   nodeToReplaceWith: DetachedNode<AssignmentPattern>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type AwaitExpressionReplaceSignature = (
   target: AwaitExpression,
   nodeToReplaceWith: DetachedNode<AwaitExpression>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type BigIntLiteralTypeAnnotationReplaceSignature = (
   target: BigIntLiteralTypeAnnotation,
   nodeToReplaceWith: DetachedNode<BigIntLiteralTypeAnnotation>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type BigIntTypeAnnotationReplaceSignature = (
   target: BigIntTypeAnnotation,
   nodeToReplaceWith: DetachedNode<BigIntTypeAnnotation>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type BinaryExpressionReplaceSignature = (
   target: BinaryExpression,
   nodeToReplaceWith: DetachedNode<BinaryExpression>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type BlockStatementReplaceSignature = (
   target: BlockStatement,
   nodeToReplaceWith: DetachedNode<BlockStatement>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type BooleanLiteralTypeAnnotationReplaceSignature = (
   target: BooleanLiteralTypeAnnotation,
   nodeToReplaceWith: DetachedNode<BooleanLiteralTypeAnnotation>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type BooleanTypeAnnotationReplaceSignature = (
   target: BooleanTypeAnnotation,
   nodeToReplaceWith: DetachedNode<BooleanTypeAnnotation>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type BreakStatementReplaceSignature = (
   target: BreakStatement,
   nodeToReplaceWith: DetachedNode<BreakStatement>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type CallExpressionReplaceSignature = (
   target: CallExpression,
   nodeToReplaceWith: DetachedNode<CallExpression>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type CatchClauseReplaceSignature = (
   target: CatchClause,
   nodeToReplaceWith: DetachedNode<CatchClause>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type ChainExpressionReplaceSignature = (
   target: ChainExpression,
   nodeToReplaceWith: DetachedNode<ChainExpression>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type ClassBodyReplaceSignature = (
   target: ClassBody,
   nodeToReplaceWith: DetachedNode<ClassBody>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type ClassDeclarationReplaceSignature = (
   target: ClassDeclaration,
   nodeToReplaceWith: DetachedNode<ClassDeclaration>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type ClassExpressionReplaceSignature = (
   target: ClassExpression,
   nodeToReplaceWith: DetachedNode<ClassExpression>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type ClassImplementsReplaceSignature = (
   target: ClassImplements,
   nodeToReplaceWith: DetachedNode<ClassImplements>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type ComponentDeclarationReplaceSignature = (
   target: ComponentDeclaration,
   nodeToReplaceWith: DetachedNode<ComponentDeclaration>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type ComponentParameterReplaceSignature = (
   target: ComponentParameter,
   nodeToReplaceWith: DetachedNode<ComponentParameter>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type ComponentTypeAnnotationReplaceSignature = (
   target: ComponentTypeAnnotation,
   nodeToReplaceWith: DetachedNode<ComponentTypeAnnotation>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type ComponentTypeParameterReplaceSignature = (
   target: ComponentTypeParameter,
   nodeToReplaceWith: DetachedNode<ComponentTypeParameter>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type ConditionalExpressionReplaceSignature = (
   target: ConditionalExpression,
   nodeToReplaceWith: DetachedNode<ConditionalExpression>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type ConditionalTypeAnnotationReplaceSignature = (
   target: ConditionalTypeAnnotation,
   nodeToReplaceWith: DetachedNode<ConditionalTypeAnnotation>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type ContinueStatementReplaceSignature = (
   target: ContinueStatement,
   nodeToReplaceWith: DetachedNode<ContinueStatement>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type DebuggerStatementReplaceSignature = (
   target: DebuggerStatement,
   nodeToReplaceWith: DetachedNode<DebuggerStatement>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type DeclareClassReplaceSignature = (
   target: DeclareClass,
   nodeToReplaceWith: DetachedNode<DeclareClass>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type DeclareComponentReplaceSignature = (
   target: DeclareComponent,
   nodeToReplaceWith: DetachedNode<DeclareComponent>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type DeclaredPredicateReplaceSignature = (
   target: DeclaredPredicate,
   nodeToReplaceWith: DetachedNode<DeclaredPredicate>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type DeclareEnumReplaceSignature = (
   target: DeclareEnum,
   nodeToReplaceWith: DetachedNode<DeclareEnum>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type DeclareExportAllDeclarationReplaceSignature = (
   target: DeclareExportAllDeclaration,
   nodeToReplaceWith: DetachedNode<DeclareExportAllDeclaration>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type DeclareExportDeclarationReplaceSignature = (
   target: DeclareExportDeclaration,
   nodeToReplaceWith: DetachedNode<DeclareExportDeclaration>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type DeclareFunctionReplaceSignature = (
   target: DeclareFunction,
   nodeToReplaceWith: DetachedNode<DeclareFunction>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type DeclareHookReplaceSignature = (
   target: DeclareHook,
   nodeToReplaceWith: DetachedNode<DeclareHook>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type DeclareInterfaceReplaceSignature = (
   target: DeclareInterface,
   nodeToReplaceWith: DetachedNode<DeclareInterface>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type DeclareModuleReplaceSignature = (
   target: DeclareModule,
   nodeToReplaceWith: DetachedNode<DeclareModule>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type DeclareModuleExportsReplaceSignature = (
   target: DeclareModuleExports,
   nodeToReplaceWith: DetachedNode<DeclareModuleExports>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type DeclareNamespaceReplaceSignature = (
   target: DeclareNamespace,
   nodeToReplaceWith: DetachedNode<DeclareNamespace>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type DeclareOpaqueTypeReplaceSignature = (
   target: DeclareOpaqueType,
   nodeToReplaceWith: DetachedNode<DeclareOpaqueType>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type DeclareTypeAliasReplaceSignature = (
   target: DeclareTypeAlias,
   nodeToReplaceWith: DetachedNode<DeclareTypeAlias>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type DeclareVariableReplaceSignature = (
   target: DeclareVariable,
   nodeToReplaceWith: DetachedNode<DeclareVariable>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type DecoratorReplaceSignature = (
   target: Decorator,
   nodeToReplaceWith: DetachedNode<Decorator>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type DoWhileStatementReplaceSignature = (
   target: DoWhileStatement,
   nodeToReplaceWith: DetachedNode<DoWhileStatement>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type EmptyStatementReplaceSignature = (
   target: EmptyStatement,
   nodeToReplaceWith: DetachedNode<EmptyStatement>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type EmptyTypeAnnotationReplaceSignature = (
   target: EmptyTypeAnnotation,
   nodeToReplaceWith: DetachedNode<EmptyTypeAnnotation>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type EnumBigIntBodyReplaceSignature = (
   target: EnumBigIntBody,
   nodeToReplaceWith: DetachedNode<EnumBigIntBody>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type EnumBigIntMemberReplaceSignature = (
   target: EnumBigIntMember,
   nodeToReplaceWith: DetachedNode<EnumBigIntMember>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type EnumBooleanBodyReplaceSignature = (
   target: EnumBooleanBody,
   nodeToReplaceWith: DetachedNode<EnumBooleanBody>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type EnumBooleanMemberReplaceSignature = (
   target: EnumBooleanMember,
   nodeToReplaceWith: DetachedNode<EnumBooleanMember>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type EnumDeclarationReplaceSignature = (
   target: EnumDeclaration,
   nodeToReplaceWith: DetachedNode<EnumDeclaration>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type EnumDefaultedMemberReplaceSignature = (
   target: EnumDefaultedMember,
   nodeToReplaceWith: DetachedNode<EnumDefaultedMember>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type EnumNumberBodyReplaceSignature = (
   target: EnumNumberBody,
   nodeToReplaceWith: DetachedNode<EnumNumberBody>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type EnumNumberMemberReplaceSignature = (
   target: EnumNumberMember,
   nodeToReplaceWith: DetachedNode<EnumNumberMember>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type EnumStringBodyReplaceSignature = (
   target: EnumStringBody,
   nodeToReplaceWith: DetachedNode<EnumStringBody>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type EnumStringMemberReplaceSignature = (
   target: EnumStringMember,
   nodeToReplaceWith: DetachedNode<EnumStringMember>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type EnumSymbolBodyReplaceSignature = (
   target: EnumSymbolBody,
   nodeToReplaceWith: DetachedNode<EnumSymbolBody>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type ExistsTypeAnnotationReplaceSignature = (
   target: ExistsTypeAnnotation,
   nodeToReplaceWith: DetachedNode<ExistsTypeAnnotation>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type ExportAllDeclarationReplaceSignature = (
   target: ExportAllDeclaration,
   nodeToReplaceWith: DetachedNode<ExportAllDeclaration>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type ExportDefaultDeclarationReplaceSignature = (
   target: ExportDefaultDeclaration,
   nodeToReplaceWith: DetachedNode<ExportDefaultDeclaration>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type ExportNamedDeclarationReplaceSignature = (
   target: ExportNamedDeclaration,
   nodeToReplaceWith: DetachedNode<ExportNamedDeclaration>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type ExportSpecifierReplaceSignature = (
   target: ExportSpecifier,
   nodeToReplaceWith: DetachedNode<ExportSpecifier>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type ExpressionStatementReplaceSignature = (
   target: ExpressionStatement,
   nodeToReplaceWith: DetachedNode<ExpressionStatement>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type ForInStatementReplaceSignature = (
   target: ForInStatement,
   nodeToReplaceWith: DetachedNode<ForInStatement>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type ForOfStatementReplaceSignature = (
   target: ForOfStatement,
   nodeToReplaceWith: DetachedNode<ForOfStatement>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type ForStatementReplaceSignature = (
   target: ForStatement,
   nodeToReplaceWith: DetachedNode<ForStatement>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type FunctionDeclarationReplaceSignature = (
   target: FunctionDeclaration,
   nodeToReplaceWith: DetachedNode<FunctionDeclaration>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type FunctionExpressionReplaceSignature = (
   target: FunctionExpression,
   nodeToReplaceWith: DetachedNode<FunctionExpression>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type FunctionTypeAnnotationReplaceSignature = (
   target: FunctionTypeAnnotation,
   nodeToReplaceWith: DetachedNode<FunctionTypeAnnotation>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type FunctionTypeParamReplaceSignature = (
   target: FunctionTypeParam,
   nodeToReplaceWith: DetachedNode<FunctionTypeParam>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type GenericTypeAnnotationReplaceSignature = (
   target: GenericTypeAnnotation,
   nodeToReplaceWith: DetachedNode<GenericTypeAnnotation>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type HookDeclarationReplaceSignature = (
   target: HookDeclaration,
   nodeToReplaceWith: DetachedNode<HookDeclaration>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type HookTypeAnnotationReplaceSignature = (
   target: HookTypeAnnotation,
   nodeToReplaceWith: DetachedNode<HookTypeAnnotation>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type IdentifierReplaceSignature = (
   target: Identifier,
   nodeToReplaceWith: DetachedNode<Identifier>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type IfStatementReplaceSignature = (
   target: IfStatement,
   nodeToReplaceWith: DetachedNode<IfStatement>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type ImportAttributeReplaceSignature = (
   target: ImportAttribute,
   nodeToReplaceWith: DetachedNode<ImportAttribute>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type ImportDeclarationReplaceSignature = (
   target: ImportDeclaration,
   nodeToReplaceWith: DetachedNode<ImportDeclaration>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type ImportDefaultSpecifierReplaceSignature = (
   target: ImportDefaultSpecifier,
   nodeToReplaceWith: DetachedNode<ImportDefaultSpecifier>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type ImportExpressionReplaceSignature = (
   target: ImportExpression,
   nodeToReplaceWith: DetachedNode<ImportExpression>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type ImportNamespaceSpecifierReplaceSignature = (
   target: ImportNamespaceSpecifier,
   nodeToReplaceWith: DetachedNode<ImportNamespaceSpecifier>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type ImportSpecifierReplaceSignature = (
   target: ImportSpecifier,
   nodeToReplaceWith: DetachedNode<ImportSpecifier>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type IndexedAccessTypeReplaceSignature = (
   target: IndexedAccessType,
   nodeToReplaceWith: DetachedNode<IndexedAccessType>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type InferredPredicateReplaceSignature = (
   target: InferredPredicate,
   nodeToReplaceWith: DetachedNode<InferredPredicate>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type InferTypeAnnotationReplaceSignature = (
   target: InferTypeAnnotation,
   nodeToReplaceWith: DetachedNode<InferTypeAnnotation>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type InterfaceDeclarationReplaceSignature = (
   target: InterfaceDeclaration,
   nodeToReplaceWith: DetachedNode<InterfaceDeclaration>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type InterfaceExtendsReplaceSignature = (
   target: InterfaceExtends,
   nodeToReplaceWith: DetachedNode<InterfaceExtends>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type InterfaceTypeAnnotationReplaceSignature = (
   target: InterfaceTypeAnnotation,
   nodeToReplaceWith: DetachedNode<InterfaceTypeAnnotation>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type IntersectionTypeAnnotationReplaceSignature = (
   target: IntersectionTypeAnnotation,
   nodeToReplaceWith: DetachedNode<IntersectionTypeAnnotation>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type JSXAttributeReplaceSignature = (
   target: JSXAttribute,
   nodeToReplaceWith: DetachedNode<JSXAttribute>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type JSXClosingElementReplaceSignature = (
   target: JSXClosingElement,
   nodeToReplaceWith: DetachedNode<JSXClosingElement>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type JSXClosingFragmentReplaceSignature = (
   target: JSXClosingFragment,
   nodeToReplaceWith: DetachedNode<JSXClosingFragment>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type JSXElementReplaceSignature = (
   target: JSXElement,
   nodeToReplaceWith: DetachedNode<JSXElement>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type JSXEmptyExpressionReplaceSignature = (
   target: JSXEmptyExpression,
   nodeToReplaceWith: DetachedNode<JSXEmptyExpression>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type JSXExpressionContainerReplaceSignature = (
   target: JSXExpressionContainer,
   nodeToReplaceWith: DetachedNode<JSXExpressionContainer>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type JSXFragmentReplaceSignature = (
   target: JSXFragment,
   nodeToReplaceWith: DetachedNode<JSXFragment>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type JSXIdentifierReplaceSignature = (
   target: JSXIdentifier,
   nodeToReplaceWith: DetachedNode<JSXIdentifier>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type JSXMemberExpressionReplaceSignature = (
   target: JSXMemberExpression,
   nodeToReplaceWith: DetachedNode<JSXMemberExpression>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type JSXNamespacedNameReplaceSignature = (
   target: JSXNamespacedName,
   nodeToReplaceWith: DetachedNode<JSXNamespacedName>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type JSXOpeningElementReplaceSignature = (
   target: JSXOpeningElement,
   nodeToReplaceWith: DetachedNode<JSXOpeningElement>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type JSXOpeningFragmentReplaceSignature = (
   target: JSXOpeningFragment,
   nodeToReplaceWith: DetachedNode<JSXOpeningFragment>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type JSXSpreadAttributeReplaceSignature = (
   target: JSXSpreadAttribute,
   nodeToReplaceWith: DetachedNode<JSXSpreadAttribute>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type JSXSpreadChildReplaceSignature = (
   target: JSXSpreadChild,
   nodeToReplaceWith: DetachedNode<JSXSpreadChild>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type JSXTextReplaceSignature = (
   target: JSXText,
   nodeToReplaceWith: DetachedNode<JSXText>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type KeyofTypeAnnotationReplaceSignature = (
   target: KeyofTypeAnnotation,
   nodeToReplaceWith: DetachedNode<KeyofTypeAnnotation>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type LabeledStatementReplaceSignature = (
   target: LabeledStatement,
   nodeToReplaceWith: DetachedNode<LabeledStatement>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type LogicalExpressionReplaceSignature = (
   target: LogicalExpression,
   nodeToReplaceWith: DetachedNode<LogicalExpression>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type MatchArrayPatternReplaceSignature = (
   target: MatchArrayPattern,
   nodeToReplaceWith: DetachedNode<MatchArrayPattern>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type MatchAsPatternReplaceSignature = (
   target: MatchAsPattern,
   nodeToReplaceWith: DetachedNode<MatchAsPattern>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type MatchBindingPatternReplaceSignature = (
   target: MatchBindingPattern,
   nodeToReplaceWith: DetachedNode<MatchBindingPattern>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type MatchExpressionReplaceSignature = (
   target: MatchExpression,
   nodeToReplaceWith: DetachedNode<MatchExpression>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type MatchExpressionCaseReplaceSignature = (
   target: MatchExpressionCase,
   nodeToReplaceWith: DetachedNode<MatchExpressionCase>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type MatchIdentifierPatternReplaceSignature = (
   target: MatchIdentifierPattern,
   nodeToReplaceWith: DetachedNode<MatchIdentifierPattern>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type MatchInstanceObjectPatternReplaceSignature = (
   target: MatchInstanceObjectPattern,
   nodeToReplaceWith: DetachedNode<MatchInstanceObjectPattern>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type MatchInstancePatternReplaceSignature = (
   target: MatchInstancePattern,
   nodeToReplaceWith: DetachedNode<MatchInstancePattern>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type MatchLiteralPatternReplaceSignature = (
   target: MatchLiteralPattern,
   nodeToReplaceWith: DetachedNode<MatchLiteralPattern>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type MatchMemberPatternReplaceSignature = (
   target: MatchMemberPattern,
   nodeToReplaceWith: DetachedNode<MatchMemberPattern>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type MatchObjectPatternReplaceSignature = (
   target: MatchObjectPattern,
   nodeToReplaceWith: DetachedNode<MatchObjectPattern>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type MatchObjectPatternPropertyReplaceSignature = (
   target: MatchObjectPatternProperty,
   nodeToReplaceWith: DetachedNode<MatchObjectPatternProperty>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type MatchOrPatternReplaceSignature = (
   target: MatchOrPattern,
   nodeToReplaceWith: DetachedNode<MatchOrPattern>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type MatchRestPatternReplaceSignature = (
   target: MatchRestPattern,
   nodeToReplaceWith: DetachedNode<MatchRestPattern>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type MatchStatementReplaceSignature = (
   target: MatchStatement,
   nodeToReplaceWith: DetachedNode<MatchStatement>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type MatchStatementCaseReplaceSignature = (
   target: MatchStatementCase,
   nodeToReplaceWith: DetachedNode<MatchStatementCase>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type MatchUnaryPatternReplaceSignature = (
   target: MatchUnaryPattern,
   nodeToReplaceWith: DetachedNode<MatchUnaryPattern>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type MatchWildcardPatternReplaceSignature = (
   target: MatchWildcardPattern,
   nodeToReplaceWith: DetachedNode<MatchWildcardPattern>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type MemberExpressionReplaceSignature = (
   target: MemberExpression,
   nodeToReplaceWith: DetachedNode<MemberExpression>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type MetaPropertyReplaceSignature = (
   target: MetaProperty,
   nodeToReplaceWith: DetachedNode<MetaProperty>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type MethodDefinitionReplaceSignature = (
   target: MethodDefinition,
   nodeToReplaceWith: DetachedNode<MethodDefinition>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type MixedTypeAnnotationReplaceSignature = (
   target: MixedTypeAnnotation,
   nodeToReplaceWith: DetachedNode<MixedTypeAnnotation>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type NeverTypeAnnotationReplaceSignature = (
   target: NeverTypeAnnotation,
   nodeToReplaceWith: DetachedNode<NeverTypeAnnotation>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type NewExpressionReplaceSignature = (
   target: NewExpression,
   nodeToReplaceWith: DetachedNode<NewExpression>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type NullableTypeAnnotationReplaceSignature = (
   target: NullableTypeAnnotation,
   nodeToReplaceWith: DetachedNode<NullableTypeAnnotation>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type NullLiteralTypeAnnotationReplaceSignature = (
   target: NullLiteralTypeAnnotation,
   nodeToReplaceWith: DetachedNode<NullLiteralTypeAnnotation>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type NumberLiteralTypeAnnotationReplaceSignature = (
   target: NumberLiteralTypeAnnotation,
   nodeToReplaceWith: DetachedNode<NumberLiteralTypeAnnotation>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type NumberTypeAnnotationReplaceSignature = (
   target: NumberTypeAnnotation,
   nodeToReplaceWith: DetachedNode<NumberTypeAnnotation>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type ObjectExpressionReplaceSignature = (
   target: ObjectExpression,
   nodeToReplaceWith: DetachedNode<ObjectExpression>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type ObjectPatternReplaceSignature = (
   target: ObjectPattern,
   nodeToReplaceWith: DetachedNode<ObjectPattern>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type ObjectTypeAnnotationReplaceSignature = (
   target: ObjectTypeAnnotation,
   nodeToReplaceWith: DetachedNode<ObjectTypeAnnotation>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type ObjectTypeCallPropertyReplaceSignature = (
   target: ObjectTypeCallProperty,
   nodeToReplaceWith: DetachedNode<ObjectTypeCallProperty>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type ObjectTypeIndexerReplaceSignature = (
   target: ObjectTypeIndexer,
   nodeToReplaceWith: DetachedNode<ObjectTypeIndexer>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type ObjectTypeInternalSlotReplaceSignature = (
   target: ObjectTypeInternalSlot,
   nodeToReplaceWith: DetachedNode<ObjectTypeInternalSlot>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type ObjectTypeMappedTypePropertyReplaceSignature = (
   target: ObjectTypeMappedTypeProperty,
   nodeToReplaceWith: DetachedNode<ObjectTypeMappedTypeProperty>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type ObjectTypePropertyReplaceSignature = (
   target: ObjectTypeProperty,
   nodeToReplaceWith: DetachedNode<ObjectTypeProperty>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type ObjectTypeSpreadPropertyReplaceSignature = (
   target: ObjectTypeSpreadProperty,
   nodeToReplaceWith: DetachedNode<ObjectTypeSpreadProperty>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type OpaqueTypeReplaceSignature = (
   target: OpaqueType,
   nodeToReplaceWith: DetachedNode<OpaqueType>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type OptionalIndexedAccessTypeReplaceSignature = (
   target: OptionalIndexedAccessType,
   nodeToReplaceWith: DetachedNode<OptionalIndexedAccessType>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type PrivateIdentifierReplaceSignature = (
   target: PrivateIdentifier,
   nodeToReplaceWith: DetachedNode<PrivateIdentifier>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type ProgramReplaceSignature = (
   target: Program,
   nodeToReplaceWith: DetachedNode<Program>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type PropertyReplaceSignature = (
   target: Property,
   nodeToReplaceWith: DetachedNode<Property>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type PropertyDefinitionReplaceSignature = (
   target: PropertyDefinition,
   nodeToReplaceWith: DetachedNode<PropertyDefinition>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type QualifiedTypeIdentifierReplaceSignature = (
   target: QualifiedTypeIdentifier,
   nodeToReplaceWith: DetachedNode<QualifiedTypeIdentifier>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type QualifiedTypeofIdentifierReplaceSignature = (
   target: QualifiedTypeofIdentifier,
   nodeToReplaceWith: DetachedNode<QualifiedTypeofIdentifier>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type RecordDeclarationReplaceSignature = (
   target: RecordDeclaration,
   nodeToReplaceWith: DetachedNode<RecordDeclaration>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type RecordDeclarationBodyReplaceSignature = (
   target: RecordDeclarationBody,
   nodeToReplaceWith: DetachedNode<RecordDeclarationBody>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type RecordDeclarationImplementsReplaceSignature = (
   target: RecordDeclarationImplements,
   nodeToReplaceWith: DetachedNode<RecordDeclarationImplements>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type RecordDeclarationPropertyReplaceSignature = (
   target: RecordDeclarationProperty,
   nodeToReplaceWith: DetachedNode<RecordDeclarationProperty>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type RecordDeclarationStaticPropertyReplaceSignature = (
   target: RecordDeclarationStaticProperty,
   nodeToReplaceWith: DetachedNode<RecordDeclarationStaticProperty>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type RecordExpressionReplaceSignature = (
   target: RecordExpression,
   nodeToReplaceWith: DetachedNode<RecordExpression>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type RecordExpressionPropertiesReplaceSignature = (
   target: RecordExpressionProperties,
   nodeToReplaceWith: DetachedNode<RecordExpressionProperties>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type RestElementReplaceSignature = (
   target: RestElement,
   nodeToReplaceWith: DetachedNode<RestElement>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type ReturnStatementReplaceSignature = (
   target: ReturnStatement,
   nodeToReplaceWith: DetachedNode<ReturnStatement>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type SequenceExpressionReplaceSignature = (
   target: SequenceExpression,
   nodeToReplaceWith: DetachedNode<SequenceExpression>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type SpreadElementReplaceSignature = (
   target: SpreadElement,
   nodeToReplaceWith: DetachedNode<SpreadElement>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type StaticBlockReplaceSignature = (
   target: StaticBlock,
   nodeToReplaceWith: DetachedNode<StaticBlock>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type StringLiteralTypeAnnotationReplaceSignature = (
   target: StringLiteralTypeAnnotation,
   nodeToReplaceWith: DetachedNode<StringLiteralTypeAnnotation>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type StringTypeAnnotationReplaceSignature = (
   target: StringTypeAnnotation,
   nodeToReplaceWith: DetachedNode<StringTypeAnnotation>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type SuperReplaceSignature = (
   target: Super,
   nodeToReplaceWith: DetachedNode<Super>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type SwitchCaseReplaceSignature = (
   target: SwitchCase,
   nodeToReplaceWith: DetachedNode<SwitchCase>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type SwitchStatementReplaceSignature = (
   target: SwitchStatement,
   nodeToReplaceWith: DetachedNode<SwitchStatement>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type SymbolTypeAnnotationReplaceSignature = (
   target: SymbolTypeAnnotation,
   nodeToReplaceWith: DetachedNode<SymbolTypeAnnotation>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type TaggedTemplateExpressionReplaceSignature = (
   target: TaggedTemplateExpression,
   nodeToReplaceWith: DetachedNode<TaggedTemplateExpression>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type TemplateElementReplaceSignature = (
   target: TemplateElement,
   nodeToReplaceWith: DetachedNode<TemplateElement>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type TemplateLiteralReplaceSignature = (
   target: TemplateLiteral,
   nodeToReplaceWith: DetachedNode<TemplateLiteral>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type ThisExpressionReplaceSignature = (
   target: ThisExpression,
   nodeToReplaceWith: DetachedNode<ThisExpression>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type ThisTypeAnnotationReplaceSignature = (
   target: ThisTypeAnnotation,
   nodeToReplaceWith: DetachedNode<ThisTypeAnnotation>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type ThrowStatementReplaceSignature = (
   target: ThrowStatement,
   nodeToReplaceWith: DetachedNode<ThrowStatement>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type TryStatementReplaceSignature = (
   target: TryStatement,
   nodeToReplaceWith: DetachedNode<TryStatement>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type TupleTypeAnnotationReplaceSignature = (
   target: TupleTypeAnnotation,
   nodeToReplaceWith: DetachedNode<TupleTypeAnnotation>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type TupleTypeLabeledElementReplaceSignature = (
   target: TupleTypeLabeledElement,
   nodeToReplaceWith: DetachedNode<TupleTypeLabeledElement>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type TupleTypeSpreadElementReplaceSignature = (
   target: TupleTypeSpreadElement,
   nodeToReplaceWith: DetachedNode<TupleTypeSpreadElement>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type TypeAliasReplaceSignature = (
   target: TypeAlias,
   nodeToReplaceWith: DetachedNode<TypeAlias>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type TypeAnnotationReplaceSignature = (
   target: TypeAnnotation,
   nodeToReplaceWith: DetachedNode<TypeAnnotation>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type TypeCastExpressionReplaceSignature = (
   target: TypeCastExpression,
   nodeToReplaceWith: DetachedNode<TypeCastExpression>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type TypeofTypeAnnotationReplaceSignature = (
   target: TypeofTypeAnnotation,
   nodeToReplaceWith: DetachedNode<TypeofTypeAnnotation>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type TypeOperatorReplaceSignature = (
   target: TypeOperator,
   nodeToReplaceWith: DetachedNode<TypeOperator>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type TypeParameterReplaceSignature = (
   target: TypeParameter,
   nodeToReplaceWith: DetachedNode<TypeParameter>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type TypeParameterDeclarationReplaceSignature = (
   target: TypeParameterDeclaration,
   nodeToReplaceWith: DetachedNode<TypeParameterDeclaration>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type TypeParameterInstantiationReplaceSignature = (
   target: TypeParameterInstantiation,
   nodeToReplaceWith: DetachedNode<TypeParameterInstantiation>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type TypePredicateReplaceSignature = (
   target: TypePredicate,
   nodeToReplaceWith: DetachedNode<TypePredicate>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type UnaryExpressionReplaceSignature = (
   target: UnaryExpression,
   nodeToReplaceWith: DetachedNode<UnaryExpression>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type UndefinedTypeAnnotationReplaceSignature = (
   target: UndefinedTypeAnnotation,
   nodeToReplaceWith: DetachedNode<UndefinedTypeAnnotation>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type UnionTypeAnnotationReplaceSignature = (
   target: UnionTypeAnnotation,
   nodeToReplaceWith: DetachedNode<UnionTypeAnnotation>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type UnknownTypeAnnotationReplaceSignature = (
   target: UnknownTypeAnnotation,
   nodeToReplaceWith: DetachedNode<UnknownTypeAnnotation>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type UpdateExpressionReplaceSignature = (
   target: UpdateExpression,
   nodeToReplaceWith: DetachedNode<UpdateExpression>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type VariableDeclarationReplaceSignature = (
   target: VariableDeclaration,
   nodeToReplaceWith: DetachedNode<VariableDeclaration>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type VariableDeclaratorReplaceSignature = (
   target: VariableDeclarator,
   nodeToReplaceWith: DetachedNode<VariableDeclarator>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type VarianceReplaceSignature = (
   target: Variance,
   nodeToReplaceWith: DetachedNode<Variance>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type VoidTypeAnnotationReplaceSignature = (
   target: VoidTypeAnnotation,
   nodeToReplaceWith: DetachedNode<VoidTypeAnnotation>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type WhileStatementReplaceSignature = (
   target: WhileStatement,
   nodeToReplaceWith: DetachedNode<WhileStatement>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type WithStatementReplaceSignature = (
   target: WithStatement,
   nodeToReplaceWith: DetachedNode<WithStatement>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type YieldExpressionReplaceSignature = (
   target: YieldExpression,
   nodeToReplaceWith: DetachedNode<YieldExpression>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 type LiteralReplaceSignature = (
   target: Literal,
   nodeToReplaceWith: DetachedNode<Literal>,
-  options?: $ReadOnly<{keepComments?: boolean}>,
+  options?: Readonly<{keepComments?: boolean}>,
 ) => void;
 export type TransformReplaceSignatures = AnyTypeAnnotationReplaceSignature &
   ArrayExpressionReplaceSignature &