diff --git a/packages/react-native-codegen/src/generators/modules/GenerateModuleCpp.js b/packages/react-native-codegen/src/generators/modules/GenerateModuleCpp.js
index e6306738b9e..919eba79edc 100644
--- a/packages/react-native-codegen/src/generators/modules/GenerateModuleCpp.js
+++ b/packages/react-native-codegen/src/generators/modules/GenerateModuleCpp.js
@@ -25,10 +25,10 @@ const {unwrapNullable} = require('../../parsers/flow/modules/utils');
 type FilesOutput = Map<string, string>;
 
 const propertyHeaderTemplate =
-  'static jsi::Value __hostFunction_::_CODEGEN_MODULE_NAME_::CxxSpecJSI_::_PROPERTY_NAME_::(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {';
+  'static jsi::Value __hostFunction_::_HASTE_MODULE_NAME_::CxxSpecJSI_::_PROPERTY_NAME_::(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {';
 
 const propertyCastTemplate =
-  'static_cast<::_CODEGEN_MODULE_NAME_::CxxSpecJSI *>(&turboModule)->::_PROPERTY_NAME_::(rt::_ARGS_::);';
+  'static_cast<::_HASTE_MODULE_NAME_::CxxSpecJSI *>(&turboModule)->::_PROPERTY_NAME_::(rt::_ARGS_::);';
 
 const nonvoidPropertyTemplate = `${propertyHeaderTemplate}
   return ${propertyCastTemplate}
@@ -40,11 +40,11 @@ const voidPropertyTemplate = `${propertyHeaderTemplate}
 }`;
 
 const proprertyDefTemplate =
-  '  methodMap_["::_PROPERTY_NAME_::"] = MethodMetadata {::_ARGS_COUNT_::, __hostFunction_::_CODEGEN_MODULE_NAME_::CxxSpecJSI_::_PROPERTY_NAME_::};';
+  '  methodMap_["::_PROPERTY_NAME_::"] = MethodMetadata {::_ARGS_COUNT_::, __hostFunction_::_HASTE_MODULE_NAME_::CxxSpecJSI_::_PROPERTY_NAME_::};';
 
 const moduleTemplate = `::_MODULE_PROPERTIES_::
 
-::_CODEGEN_MODULE_NAME_::CxxSpecJSI::::_CODEGEN_MODULE_NAME_::CxxSpecJSI(std::shared_ptr<CallInvoker> jsInvoker)
+::_HASTE_MODULE_NAME_::CxxSpecJSI::::_HASTE_MODULE_NAME_::CxxSpecJSI(std::shared_ptr<CallInvoker> jsInvoker)
   : TurboModule("::_NATIVE_MODULE_NAME_::", jsInvoker) {
 ::_PROPERTIES_MAP_::
 }`.trim();
@@ -157,8 +157,8 @@ module.exports = {
     const nativeModules = getModules(schema);
 
     const modules = Object.keys(nativeModules)
-      .map(codegenModuleName => {
-        const nativeModule = nativeModules[codegenModuleName];
+      .map(hasteModuleName => {
+        const nativeModule = nativeModules[hasteModuleName];
         const {
           aliases,
           spec: {properties},
@@ -189,7 +189,7 @@ module.exports = {
                 )
                 .join('\n'),
             )
-            .replace(/::_CODEGEN_MODULE_NAME_::/g, codegenModuleName)
+            .replace(/::_HASTE_MODULE_NAME_::/g, hasteModuleName)
         );
       })
       .join('\n');
diff --git a/packages/react-native-codegen/src/generators/modules/GenerateModuleH.js b/packages/react-native-codegen/src/generators/modules/GenerateModuleH.js
index 9e4b5061d18..37b7b38f3ea 100644
--- a/packages/react-native-codegen/src/generators/modules/GenerateModuleH.js
+++ b/packages/react-native-codegen/src/generators/modules/GenerateModuleH.js
@@ -23,9 +23,9 @@ const {unwrapNullable} = require('../../parsers/flow/modules/utils');
 
 type FilesOutput = Map<string, string>;
 
-const moduleTemplate = `class JSI_EXPORT ::_CODEGEN_MODULE_NAME_::CxxSpecJSI : public TurboModule {
+const moduleTemplate = `class JSI_EXPORT ::_HASTE_MODULE_NAME_::CxxSpecJSI : public TurboModule {
 protected:
-  ::_CODEGEN_MODULE_NAME_::CxxSpecJSI(std::shared_ptr<CallInvoker> jsInvoker);
+  ::_HASTE_MODULE_NAME_::CxxSpecJSI(std::shared_ptr<CallInvoker> jsInvoker);
 
 public:
 ::_MODULE_PROPERTIES_::
@@ -117,11 +117,11 @@ module.exports = {
     const nativeModules = getModules(schema);
 
     const modules = Object.keys(nativeModules)
-      .map(codegenModuleName => {
+      .map(hasteModuleName => {
         const {
           aliases,
           spec: {properties},
-        } = nativeModules[codegenModuleName];
+        } = nativeModules[hasteModuleName];
         const resolveAlias = createAliasResolver(aliases);
 
         const traversedProperties = properties
@@ -166,7 +166,7 @@ module.exports = {
           .join('\n');
         return moduleTemplate
           .replace(/::_MODULE_PROPERTIES_::/g, traversedProperties)
-          .replace(/::_CODEGEN_MODULE_NAME_::/g, codegenModuleName)
+          .replace(/::_HASTE_MODULE_NAME_::/g, hasteModuleName)
           .replace('::_PROPERTIES_MAP_::', '');
       })
       .join('\n');
diff --git a/packages/react-native-codegen/src/generators/modules/GenerateModuleJavaSpec.js b/packages/react-native-codegen/src/generators/modules/GenerateModuleJavaSpec.js
index 2b263a04642..d6c2ce131cf 100644
--- a/packages/react-native-codegen/src/generators/modules/GenerateModuleJavaSpec.js
+++ b/packages/react-native-codegen/src/generators/modules/GenerateModuleJavaSpec.js
@@ -278,17 +278,17 @@ module.exports = {
     const packageName = 'com.facebook.fbreact.specs.beta';
     const nativeModules = getModules(schema);
 
-    Object.keys(nativeModules).forEach(codegenModuleName => {
+    Object.keys(nativeModules).forEach(hasteModuleName => {
       const {
         aliases,
         excludedPlatforms,
         spec: {properties},
-      } = nativeModules[codegenModuleName];
+      } = nativeModules[hasteModuleName];
       if (excludedPlatforms != null && excludedPlatforms.includes('android')) {
         return;
       }
       const resolveAlias = createAliasResolver(aliases);
-      const className = `${codegenModuleName}Spec`;
+      const className = `${hasteModuleName}Spec`;
 
       const imports: Set<string> = new Set([
         // Always required.
diff --git a/packages/react-native-codegen/src/generators/modules/GenerateModuleJniCpp.js b/packages/react-native-codegen/src/generators/modules/GenerateModuleJniCpp.js
index 4a30a0b25c1..a81655f3b83 100644
--- a/packages/react-native-codegen/src/generators/modules/GenerateModuleJniCpp.js
+++ b/packages/react-native-codegen/src/generators/modules/GenerateModuleJniCpp.js
@@ -27,7 +27,7 @@ const {unwrapNullable} = require('../../parsers/flow/modules/utils');
 type FilesOutput = Map<string, string>;
 
 const propertyHeaderTemplate =
-  'static facebook::jsi::Value __hostFunction_::_CODEGEN_MODULE_NAME_::SpecJSI_::_PROPERTY_NAME_::(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {';
+  'static facebook::jsi::Value __hostFunction_::_HASTE_MODULE_NAME_::SpecJSI_::_PROPERTY_NAME_::(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {';
 
 const propertyCastTemplate =
   'static_cast<JavaTurboModule &>(turboModule).invokeJavaMethod(rt, ::_KIND_::, "::_PROPERTY_NAME_::", "::_SIGNATURE_::", args, count);';
@@ -38,18 +38,18 @@ ${propertyHeaderTemplate}
 }`;
 
 const propertyDefTemplate =
-  '  methodMap_["::_PROPERTY_NAME_::"] = MethodMetadata {::_ARGS_COUNT_::, __hostFunction_::_CODEGEN_MODULE_NAME_::SpecJSI_::_PROPERTY_NAME_::};';
+  '  methodMap_["::_PROPERTY_NAME_::"] = MethodMetadata {::_ARGS_COUNT_::, __hostFunction_::_HASTE_MODULE_NAME_::SpecJSI_::_PROPERTY_NAME_::};';
 
 const moduleTemplate = `
 ::_TURBOMODULE_METHOD_INVOKERS_::
 
-::_CODEGEN_MODULE_NAME_::SpecJSI::::_CODEGEN_MODULE_NAME_::SpecJSI(const JavaTurboModule::InitParams &params)
+::_HASTE_MODULE_NAME_::SpecJSI::::_HASTE_MODULE_NAME_::SpecJSI(const JavaTurboModule::InitParams &params)
   : JavaTurboModule(params) {
 ::_PROPERTIES_MAP_::
 }`.trim();
 
 const oneModuleLookupTemplate = `  if (moduleName == "::_NATIVE_MODULE_NAME_::") {
-    return std::make_shared<::_CODEGEN_MODULE_NAME_::SpecJSI>(params);
+    return std::make_shared<::_HASTE_MODULE_NAME_::SpecJSI>(params);
   }`;
 
 const template = `
@@ -334,19 +334,19 @@ module.exports = {
     const nativeModules = getModules(schema);
 
     const modules = Object.keys(nativeModules)
-      .filter(codegenModuleName => {
-        const module = nativeModules[codegenModuleName];
+      .filter(hasteModuleName => {
+        const module = nativeModules[hasteModuleName];
         return !(
           module.excludedPlatforms != null &&
           module.excludedPlatforms.includes('android')
         );
       })
       .sort()
-      .map(codegenModuleName => {
+      .map(hasteModuleName => {
         const {
           aliases,
           spec: {properties},
-        } = nativeModules[codegenModuleName];
+        } = nativeModules[hasteModuleName];
         const resolveAlias = createAliasResolver(aliases);
 
         const translatedMethods = properties
@@ -377,13 +377,13 @@ module.exports = {
               })
               .join('\n'),
           )
-          .replace(/::_CODEGEN_MODULE_NAME_::/g, codegenModuleName);
+          .replace(/::_HASTE_MODULE_NAME_::/g, hasteModuleName);
       })
       .join('\n');
 
     const moduleLookup = Object.keys(nativeModules)
-      .filter(codegenModuleName => {
-        const module = nativeModules[codegenModuleName];
+      .filter(hasteModuleName => {
+        const module = nativeModules[hasteModuleName];
         return !(
           module.excludedPlatforms != null &&
           module.excludedPlatforms.includes('android')
@@ -401,13 +401,13 @@ module.exports = {
         }
         return 0;
       })
-      .map(codegenModuleName => {
-        const {moduleNames} = nativeModules[codegenModuleName];
+      .map(hasteModuleName => {
+        const {moduleNames} = nativeModules[hasteModuleName];
         return moduleNames
           .map(nativeModuleName =>
             oneModuleLookupTemplate
               .replace(/::_NATIVE_MODULE_NAME_::/g, nativeModuleName)
-              .replace(/::_CODEGEN_MODULE_NAME_::/g, codegenModuleName),
+              .replace(/::_HASTE_MODULE_NAME_::/g, hasteModuleName),
           )
           .join('\n');
       })
diff --git a/packages/react-native-codegen/src/generators/modules/GenerateModuleJniH.js b/packages/react-native-codegen/src/generators/modules/GenerateModuleJniH.js
index 9be43efbd6f..3233d991a1b 100644
--- a/packages/react-native-codegen/src/generators/modules/GenerateModuleJniH.js
+++ b/packages/react-native-codegen/src/generators/modules/GenerateModuleJniH.js
@@ -17,11 +17,11 @@ type FilesOutput = Map<string, string>;
 const {getModules} = require('./Utils');
 
 const moduleSpecTemplate = `/**
- * JNI C++ class for module '::_CODEGEN_MODULE_NAME_::'
+ * JNI C++ class for module '::_HASTE_MODULE_NAME_::'
  */
-class JSI_EXPORT ::_CODEGEN_MODULE_NAME_::SpecJSI : public JavaTurboModule {
+class JSI_EXPORT ::_HASTE_MODULE_NAME_::SpecJSI : public JavaTurboModule {
 public:
-  ::_CODEGEN_MODULE_NAME_::SpecJSI(const JavaTurboModule::InitParams &params);
+  ::_HASTE_MODULE_NAME_::SpecJSI(const JavaTurboModule::InitParams &params);
 };
 `;
 
@@ -89,19 +89,16 @@ module.exports = {
   ): FilesOutput {
     const nativeModules = getModules(schema);
     const modules = Object.keys(nativeModules)
-      .filter(codegenModuleName => {
-        const module = nativeModules[codegenModuleName];
+      .filter(hasteModuleName => {
+        const module = nativeModules[hasteModuleName];
         return !(
           module.excludedPlatforms != null &&
           module.excludedPlatforms.includes('android')
         );
       })
       .sort()
-      .map(codegenModuleName =>
-        moduleSpecTemplate.replace(
-          /::_CODEGEN_MODULE_NAME_::/g,
-          codegenModuleName,
-        ),
+      .map(hasteModuleName =>
+        moduleSpecTemplate.replace(/::_HASTE_MODULE_NAME_::/g, hasteModuleName),
       )
       .join('\n');
 
diff --git a/packages/react-native-codegen/src/generators/modules/GenerateModuleObjCpp/Utils.js b/packages/react-native-codegen/src/generators/modules/GenerateModuleObjCpp/Utils.js
index d0af538ec19..c596cebbd11 100644
--- a/packages/react-native-codegen/src/generators/modules/GenerateModuleObjCpp/Utils.js
+++ b/packages/react-native-codegen/src/generators/modules/GenerateModuleObjCpp/Utils.js
@@ -23,10 +23,10 @@ function getSafePropertyName(property: StructProperty): string {
 }
 
 function getNamespacedStructName(
-  codegenModuleName: string,
+  hasteModuleName: string,
   structName: string,
 ): string {
-  return `JS::${codegenModuleName}::${structName}`;
+  return `JS::${hasteModuleName}::${structName}`;
 }
 
 module.exports = {
diff --git a/packages/react-native-codegen/src/generators/modules/GenerateModuleObjCpp/header/serializeConstantsStruct.js b/packages/react-native-codegen/src/generators/modules/GenerateModuleObjCpp/header/serializeConstantsStruct.js
index da8ab2bbf51..0e7f2ab9e2b 100644
--- a/packages/react-native-codegen/src/generators/modules/GenerateModuleObjCpp/header/serializeConstantsStruct.js
+++ b/packages/react-native-codegen/src/generators/modules/GenerateModuleObjCpp/header/serializeConstantsStruct.js
@@ -23,15 +23,15 @@ import type {StructSerilizationOutput} from './serializeStruct';
 const {unwrapNullable} = require('../../../../parsers/flow/modules/utils');
 
 const StructTemplate = ({
-  codegenModuleName,
+  hasteModuleName,
   structName,
   builderInputProps,
 }: $ReadOnly<{|
-  codegenModuleName: string,
+  hasteModuleName: string,
   structName: string,
   builderInputProps: string,
 |}>) => `namespace JS {
-  namespace ${codegenModuleName} {
+  namespace ${hasteModuleName} {
     struct ${structName} {
 
       struct Builder {
@@ -59,24 +59,24 @@ const StructTemplate = ({
 }`;
 
 const MethodTemplate = ({
-  codegenModuleName,
+  hasteModuleName,
   structName,
   properties,
 }: $ReadOnly<{|
-  codegenModuleName: string,
+  hasteModuleName: string,
   structName: string,
   properties: string,
-|}>) => `inline JS::${codegenModuleName}::${structName}::Builder::Builder(const Input i) : _factory(^{
+|}>) => `inline JS::${hasteModuleName}::${structName}::Builder::Builder(const Input i) : _factory(^{
   NSMutableDictionary *d = [NSMutableDictionary new];
 ${properties}
   return d;
 }) {}
-inline JS::${codegenModuleName}::${structName}::Builder::Builder(${structName} i) : _factory(^{
+inline JS::${hasteModuleName}::${structName}::Builder::Builder(${structName} i) : _factory(^{
   return i.unsafeRawValue();
 }) {}`;
 
 function toObjCType(
-  codegenModuleName: string,
+  hasteModuleName: string,
   nullableTypeAnnotation: Nullable<StructTypeAnnotation>,
   isOptional: boolean = false,
 ): string {
@@ -116,14 +116,14 @@ function toObjCType(
 
       return wrapFollyOptional(
         `std::vector<${toObjCType(
-          codegenModuleName,
+          hasteModuleName,
           typeAnnotation.elementType,
         )}>`,
       );
     case 'TypeAliasTypeAnnotation':
       const structName = capitalize(typeAnnotation.name);
       const namespacedStructName = getNamespacedStructName(
-        codegenModuleName,
+        hasteModuleName,
         structName,
       );
       return wrapFollyOptional(`${namespacedStructName}::Builder`);
@@ -136,7 +136,7 @@ function toObjCType(
 }
 
 function toObjCValue(
-  codegenModuleName: string,
+  hasteModuleName: string,
   nullableTypeAnnotation: Nullable<StructTypeAnnotation>,
   value: string,
   depth: number,
@@ -183,9 +183,9 @@ function toObjCValue(
       }
 
       const localVarName = `el${'_'.repeat(depth + 1)}`;
-      const elementObjCType = toObjCType(codegenModuleName, elementType);
+      const elementObjCType = toObjCType(hasteModuleName, elementType);
       const elementObjCValue = toObjCValue(
-        codegenModuleName,
+        hasteModuleName,
         elementType,
         localVarName,
         depth + 1,
@@ -213,21 +213,17 @@ function toObjCValue(
 }
 
 function serializeConstantsStruct(
-  codegenModuleName: string,
+  hasteModuleName: string,
   struct: ConstantsStruct,
 ): StructSerilizationOutput {
   const declaration = StructTemplate({
-    codegenModuleName,
+    hasteModuleName,
     structName: struct.name,
     builderInputProps: struct.properties
       .map(property => {
         const {typeAnnotation, optional} = property;
         const propName = getSafePropertyName(property);
-        const objCType = toObjCType(
-          codegenModuleName,
-          typeAnnotation,
-          optional,
-        );
+        const objCType = toObjCType(hasteModuleName, typeAnnotation, optional);
 
         if (!optional) {
           return `RCTRequired<${objCType}> ${propName};`;
@@ -240,14 +236,14 @@ function serializeConstantsStruct(
   });
 
   const methods = MethodTemplate({
-    codegenModuleName,
+    hasteModuleName,
     structName: struct.name,
     properties: struct.properties
       .map(property => {
         const {typeAnnotation, optional} = property;
         const propName = getSafePropertyName(property);
         const objCValue = toObjCValue(
-          codegenModuleName,
+          hasteModuleName,
           typeAnnotation,
           propName,
           0,
diff --git a/packages/react-native-codegen/src/generators/modules/GenerateModuleObjCpp/header/serializeRegularStruct.js b/packages/react-native-codegen/src/generators/modules/GenerateModuleObjCpp/header/serializeRegularStruct.js
index de85dccddce..60e5859a5ca 100644
--- a/packages/react-native-codegen/src/generators/modules/GenerateModuleObjCpp/header/serializeRegularStruct.js
+++ b/packages/react-native-codegen/src/generators/modules/GenerateModuleObjCpp/header/serializeRegularStruct.js
@@ -23,15 +23,15 @@ import type {StructSerilizationOutput} from './serializeStruct';
 const {unwrapNullable} = require('../../../../parsers/flow/modules/utils');
 
 const StructTemplate = ({
-  codegenModuleName,
+  hasteModuleName,
   structName,
   structProperties,
 }: $ReadOnly<{|
-  codegenModuleName: string,
+  hasteModuleName: string,
   structName: string,
   structProperties: string,
 |}>) => `namespace JS {
-  namespace ${codegenModuleName} {
+  namespace ${hasteModuleName} {
     struct ${structName} {
       ${structProperties}
 
@@ -42,30 +42,30 @@ const StructTemplate = ({
   }
 }
 
-@interface RCTCxxConvert (${codegenModuleName}_${structName})
-+ (RCTManagedPointer *)JS_${codegenModuleName}_${structName}:(id)json;
+@interface RCTCxxConvert (${hasteModuleName}_${structName})
++ (RCTManagedPointer *)JS_${hasteModuleName}_${structName}:(id)json;
 @end`;
 
 const MethodTemplate = ({
   returnType,
   returnValue,
-  codegenModuleName,
+  hasteModuleName,
   structName,
   propertyName,
 }: $ReadOnly<{|
   returnType: string,
   returnValue: string,
-  codegenModuleName: string,
+  hasteModuleName: string,
   structName: string,
   propertyName: string,
-|}>) => `inline ${returnType}JS::${codegenModuleName}::${structName}::${propertyName}() const
+|}>) => `inline ${returnType}JS::${hasteModuleName}::${structName}::${propertyName}() const
 {
   id const p = _v[@"${propertyName}"];
   return ${returnValue};
 }`;
 
 function toObjCType(
-  codegenModuleName: string,
+  hasteModuleName: string,
   nullableTypeAnnotation: Nullable<StructTypeAnnotation>,
   isOptional: boolean = false,
 ): string {
@@ -104,14 +104,14 @@ function toObjCType(
       }
       return wrapFollyOptional(
         `facebook::react::LazyVector<${toObjCType(
-          codegenModuleName,
+          hasteModuleName,
           typeAnnotation.elementType,
         )}>`,
       );
     case 'TypeAliasTypeAnnotation':
       const structName = capitalize(typeAnnotation.name);
       const namespacedStructName = getNamespacedStructName(
-        codegenModuleName,
+        hasteModuleName,
         structName,
       );
       return wrapFollyOptional(namespacedStructName);
@@ -124,7 +124,7 @@ function toObjCType(
 }
 
 function toObjCValue(
-  codegenModuleName: string,
+  hasteModuleName: string,
   nullableTypeAnnotation: Nullable<StructTypeAnnotation>,
   value: string,
   depth: number,
@@ -171,9 +171,9 @@ function toObjCValue(
       }
 
       const localVarName = `itemValue_${depth}`;
-      const elementObjCType = toObjCType(codegenModuleName, elementType);
+      const elementObjCType = toObjCType(hasteModuleName, elementType);
       const elementObjCValue = toObjCValue(
-        codegenModuleName,
+        hasteModuleName,
         elementType,
         localVarName,
         depth + 1,
@@ -186,7 +186,7 @@ function toObjCValue(
     case 'TypeAliasTypeAnnotation':
       const structName = capitalize(typeAnnotation.name);
       const namespacedStructName = getNamespacedStructName(
-        codegenModuleName,
+        hasteModuleName,
         structName,
       );
 
@@ -202,18 +202,18 @@ function toObjCValue(
 }
 
 function serializeRegularStruct(
-  codegenModuleName: string,
+  hasteModuleName: string,
   struct: RegularStruct,
 ): StructSerilizationOutput {
   const declaration = StructTemplate({
-    codegenModuleName: codegenModuleName,
+    hasteModuleName: hasteModuleName,
     structName: struct.name,
     structProperties: struct.properties
       .map(property => {
         const {typeAnnotation, optional} = property;
         const propName = getSafePropertyName(property);
         const returnType = toObjCType(
-          codegenModuleName,
+          hasteModuleName,
           typeAnnotation,
           optional,
         );
@@ -228,13 +228,9 @@ function serializeRegularStruct(
     .map<string>(property => {
       const {typeAnnotation, optional} = property;
       const propName = getSafePropertyName(property);
-      const returnType = toObjCType(
-        codegenModuleName,
-        typeAnnotation,
-        optional,
-      );
+      const returnType = toObjCType(hasteModuleName, typeAnnotation, optional);
       const returnValue = toObjCValue(
-        codegenModuleName,
+        hasteModuleName,
         typeAnnotation,
         'p',
         0,
@@ -243,7 +239,7 @@ function serializeRegularStruct(
 
       const padding = ' '.repeat(returnType.endsWith('*') ? 0 : 1);
       return MethodTemplate({
-        codegenModuleName,
+        hasteModuleName,
         structName: struct.name,
         returnType: returnType + padding,
         returnValue: returnValue,
diff --git a/packages/react-native-codegen/src/generators/modules/GenerateModuleObjCpp/header/serializeStruct.js b/packages/react-native-codegen/src/generators/modules/GenerateModuleObjCpp/header/serializeStruct.js
index fe2355333b3..fa851d24f01 100644
--- a/packages/react-native-codegen/src/generators/modules/GenerateModuleObjCpp/header/serializeStruct.js
+++ b/packages/react-native-codegen/src/generators/modules/GenerateModuleObjCpp/header/serializeStruct.js
@@ -21,13 +21,13 @@ export type StructSerilizationOutput = $ReadOnly<{|
 |}>;
 
 function serializeStruct(
-  moduleName: string,
+  hasteModuleName: string,
   struct: Struct,
 ): StructSerilizationOutput {
   if (struct.context === 'REGULAR') {
-    return serializeRegularStruct(moduleName, struct);
+    return serializeRegularStruct(hasteModuleName, struct);
   }
-  return serializeConstantsStruct(moduleName, struct);
+  return serializeConstantsStruct(hasteModuleName, struct);
 }
 
 module.exports = {
diff --git a/packages/react-native-codegen/src/generators/modules/GenerateModuleObjCpp/index.js b/packages/react-native-codegen/src/generators/modules/GenerateModuleObjCpp/index.js
index 9c9eca23950..a2f9625f454 100644
--- a/packages/react-native-codegen/src/generators/modules/GenerateModuleObjCpp/index.js
+++ b/packages/react-native-codegen/src/generators/modules/GenerateModuleObjCpp/index.js
@@ -23,15 +23,15 @@ const {serializeModuleSource} = require('./source/serializeModule');
 type FilesOutput = Map<string, string>;
 
 const ModuleDeclarationTemplate = ({
-  codegenModuleName,
+  hasteModuleName,
   structDeclarations,
   protocolMethods,
 }: $ReadOnly<{|
-  codegenModuleName: string,
+  hasteModuleName: string,
   structDeclarations: string,
   protocolMethods: string,
 |}>) => `${structDeclarations}
-@protocol ${codegenModuleName}Spec <RCTBridgeModule, RCTTurboModule>
+@protocol ${hasteModuleName}Spec <RCTBridgeModule, RCTTurboModule>
 
 ${protocolMethods}
 
@@ -39,11 +39,11 @@ ${protocolMethods}
 namespace facebook {
   namespace react {
     /**
-     * ObjC++ class for module '${codegenModuleName}'
+     * ObjC++ class for module '${hasteModuleName}'
      */
-    class JSI_EXPORT ${codegenModuleName}SpecJSI : public ObjCTurboModule {
+    class JSI_EXPORT ${hasteModuleName}SpecJSI : public ObjCTurboModule {
     public:
-      ${codegenModuleName}SpecJSI(const ObjCTurboModule::InitParams &params);
+      ${hasteModuleName}SpecJSI(const ObjCTurboModule::InitParams &params);
     };
   } // namespace react
 } // namespace facebook`;
@@ -121,13 +121,13 @@ module.exports = {
     const structInlineMethods: Array<string> = [];
     const moduleImplementations: Array<string> = [];
 
-    const codegenModuleNames: Array<string> = Object.keys(nativeModules).sort();
-    for (const codegenModuleName of codegenModuleNames) {
+    const hasteModuleNames: Array<string> = Object.keys(nativeModules).sort();
+    for (const hasteModuleName of hasteModuleNames) {
       const {
         aliases,
         excludedPlatforms,
         spec: {properties},
-      } = nativeModules[codegenModuleName];
+      } = nativeModules[hasteModuleName];
       if (excludedPlatforms != null && excludedPlatforms.includes('iOS')) {
         continue;
       }
@@ -138,7 +138,7 @@ module.exports = {
       const serializeProperty = property => {
         methodSerializations.push(
           ...serializeMethod(
-            codegenModuleName,
+            hasteModuleName,
             property,
             structCollector,
             resolveAlias,
@@ -162,17 +162,14 @@ module.exports = {
       const methodStrs = [];
 
       for (const struct of generatedStructs) {
-        const {methods, declaration} = serializeStruct(
-          codegenModuleName,
-          struct,
-        );
+        const {methods, declaration} = serializeStruct(hasteModuleName, struct);
         structStrs.push(declaration);
         methodStrs.push(methods);
       }
 
       moduleDeclarations.push(
         ModuleDeclarationTemplate({
-          codegenModuleName: codegenModuleName,
+          hasteModuleName: hasteModuleName,
           structDeclarations: structStrs.join('\n'),
           protocolMethods: methodSerializations
             .map(({protocolMethod}) => protocolMethod)
@@ -184,7 +181,7 @@ module.exports = {
 
       moduleImplementations.push(
         serializeModuleSource(
-          codegenModuleName,
+          hasteModuleName,
           generatedStructs,
           methodSerializations.filter(
             ({selector}) => selector !== '@selector(constantsToExport)',
diff --git a/packages/react-native-codegen/src/generators/modules/GenerateModuleObjCpp/serializeMethod.js b/packages/react-native-codegen/src/generators/modules/GenerateModuleObjCpp/serializeMethod.js
index d70066fdd06..d5db63c7610 100644
--- a/packages/react-native-codegen/src/generators/modules/GenerateModuleObjCpp/serializeMethod.js
+++ b/packages/react-native-codegen/src/generators/modules/GenerateModuleObjCpp/serializeMethod.js
@@ -60,7 +60,7 @@ export type MethodSerializationOutput = $ReadOnly<{|
 |}>;
 
 function serializeMethod(
-  codegenModuleName: string,
+  hasteModuleName: string,
   property: NativeModulePropertySchema,
   structCollector: StructCollector,
   resolveAlias: AliasResolver,
@@ -71,7 +71,7 @@ function serializeMethod(
 
   if (methodName === 'getConstants') {
     return serializeConstantsProtocolMethods(
-      codegenModuleName,
+      hasteModuleName,
       property,
       structCollector,
       resolveAlias,
@@ -84,7 +84,7 @@ function serializeMethod(
   params.forEach((param, index) => {
     const structName = getParamStructName(methodName, param);
     const {objCType, isStruct} = getParamObjCType(
-      codegenModuleName,
+      hasteModuleName,
       methodName,
       param,
       structName,
@@ -177,7 +177,7 @@ function getParamStructName(
 }
 
 function getParamObjCType(
-  codegenModuleName: string,
+  hasteModuleName: string,
   methodName: string,
   param: NativeModuleMethodParamSchema,
   structName: string,
@@ -242,7 +242,7 @@ function getParamObjCType(
        * TODO(T73943261): Support nullable object literals and aliases?
        */
       return isStruct(
-        getNamespacedStructName(codegenModuleName, structTypeAnnotation.name) +
+        getNamespacedStructName(hasteModuleName, structTypeAnnotation.name) +
           ' &',
       );
     }
@@ -383,7 +383,7 @@ function getReturnJSType(
 }
 
 function serializeConstantsProtocolMethods(
-  codegenModuleName: string,
+  hasteModuleName: string,
   property: NativeModulePropertySchema,
   structCollector: StructCollector,
   resolveAlias: AliasResolver,
@@ -391,14 +391,14 @@ function serializeConstantsProtocolMethods(
   const [propertyTypeAnnotation] = unwrapNullable(property.typeAnnotation);
   if (propertyTypeAnnotation.params.length !== 0) {
     throw new Error(
-      `${codegenModuleName}.getConstants() may only accept 0 arguments.`,
+      `${hasteModuleName}.getConstants() may only accept 0 arguments.`,
     );
   }
 
   const {returnTypeAnnotation} = propertyTypeAnnotation;
   if (returnTypeAnnotation.type !== 'ObjectTypeAnnotation') {
     throw new Error(
-      `${codegenModuleName}.getConstants() may only return an object literal: {|...|}.`,
+      `${hasteModuleName}.getConstants() may only return an object literal: {|...|}.`,
     );
   }
 
@@ -418,7 +418,7 @@ function serializeConstantsProtocolMethods(
     "Unable to generate C++ struct from module's getConstants() method return type.",
   );
 
-  const returnObjCType = `facebook::react::ModuleConstants<JS::${codegenModuleName}::Constants::Builder>`;
+  const returnObjCType = `facebook::react::ModuleConstants<JS::${hasteModuleName}::Constants::Builder>`;
 
   return ['constantsToExport', 'getConstants'].map<MethodSerializationOutput>(
     methodName => {
diff --git a/packages/react-native-codegen/src/generators/modules/GenerateModuleObjCpp/source/serializeModule.js b/packages/react-native-codegen/src/generators/modules/GenerateModuleObjCpp/source/serializeModule.js
index 40a08c76720..c930f98b7d8 100644
--- a/packages/react-native-codegen/src/generators/modules/GenerateModuleObjCpp/source/serializeModule.js
+++ b/packages/react-native-codegen/src/generators/modules/GenerateModuleObjCpp/source/serializeModule.js
@@ -17,16 +17,16 @@ import type {
 } from '../serializeMethod';
 
 const ModuleTemplate = ({
-  codegenModuleName,
+  hasteModuleName,
   structs,
   methodSerializationOutputs,
 }: $ReadOnly<{|
-  codegenModuleName: string,
+  hasteModuleName: string,
   structs: $ReadOnlyArray<Struct>,
   methodSerializationOutputs: $ReadOnlyArray<MethodSerializationOutput>,
 |}>) => `${structs
   .map(struct =>
-    RCTCxxConvertCategoryTemplate({codegenModuleName, structName: struct.name}),
+    RCTCxxConvertCategoryTemplate({hasteModuleName, structName: struct.name}),
   )
   .join('\n')}
 namespace facebook {
@@ -34,7 +34,7 @@ namespace facebook {
     ${methodSerializationOutputs
       .map(serializedMethodParts =>
         InlineHostFunctionTemplate({
-          codegenModuleName,
+          hasteModuleName,
           methodName: serializedMethodParts.methodName,
           returnJSType: serializedMethodParts.returnJSType,
           selector: serializedMethodParts.selector,
@@ -42,12 +42,12 @@ namespace facebook {
       )
       .join('\n')}
 
-    ${codegenModuleName}SpecJSI::${codegenModuleName}SpecJSI(const ObjCTurboModule::InitParams &params)
+    ${hasteModuleName}SpecJSI::${hasteModuleName}SpecJSI(const ObjCTurboModule::InitParams &params)
       : ObjCTurboModule(params) {
         ${methodSerializationOutputs
           .map(({methodName, structParamRecords, argCount}) =>
             MethodMapEntryTemplate({
-              codegenModuleName,
+              hasteModuleName,
               methodName,
               structParamRecords,
               argCount,
@@ -59,58 +59,58 @@ namespace facebook {
 } // namespace facebook`;
 
 const RCTCxxConvertCategoryTemplate = ({
-  codegenModuleName,
+  hasteModuleName,
   structName,
 }: $ReadOnly<{|
-  codegenModuleName: string,
+  hasteModuleName: string,
   structName: string,
-|}>) => `@implementation RCTCxxConvert (${codegenModuleName}_${structName})
-+ (RCTManagedPointer *)JS_${codegenModuleName}_${structName}:(id)json
+|}>) => `@implementation RCTCxxConvert (${hasteModuleName}_${structName})
++ (RCTManagedPointer *)JS_${hasteModuleName}_${structName}:(id)json
 {
-  return facebook::react::managedPointer<JS::${codegenModuleName}::${structName}>(json);
+  return facebook::react::managedPointer<JS::${hasteModuleName}::${structName}>(json);
 }
 @end`;
 
 const InlineHostFunctionTemplate = ({
-  codegenModuleName,
+  hasteModuleName,
   methodName,
   returnJSType,
   selector,
 }: $ReadOnly<{|
-  codegenModuleName: string,
+  hasteModuleName: string,
   methodName: string,
   returnJSType: string,
   selector: string,
 |}>) => `
-    static facebook::jsi::Value __hostFunction_${codegenModuleName}SpecJSI_${methodName}(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+    static facebook::jsi::Value __hostFunction_${hasteModuleName}SpecJSI_${methodName}(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
       return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, ${returnJSType}, "${methodName}", ${selector}, args, count);
     }`;
 
 const MethodMapEntryTemplate = ({
-  codegenModuleName,
+  hasteModuleName,
   methodName,
   structParamRecords,
   argCount,
 }: $ReadOnly<{|
-  codegenModuleName: string,
+  hasteModuleName: string,
   methodName: string,
   structParamRecords: $ReadOnlyArray<StructParameterRecord>,
   argCount: number,
 |}>) => `
-        methodMap_["${methodName}"] = MethodMetadata {${argCount}, __hostFunction_${codegenModuleName}SpecJSI_${methodName}};
+        methodMap_["${methodName}"] = MethodMetadata {${argCount}, __hostFunction_${hasteModuleName}SpecJSI_${methodName}};
         ${structParamRecords
           .map(({paramIndex, structName}) => {
-            return `setMethodArgConversionSelector(@"${methodName}", ${paramIndex}, @"JS_${codegenModuleName}_${structName}:");`;
+            return `setMethodArgConversionSelector(@"${methodName}", ${paramIndex}, @"JS_${hasteModuleName}_${structName}:");`;
           })
           .join('\n' + ' '.repeat(8))}`;
 
 function serializeModuleSource(
-  codegenModuleName: string,
+  hasteModuleName: string,
   structs: $ReadOnlyArray<Struct>,
   methodSerializationOutputs: $ReadOnlyArray<MethodSerializationOutput>,
 ): string {
   return ModuleTemplate({
-    codegenModuleName,
+    hasteModuleName,
     structs: structs.filter(({context}) => context !== 'CONSTANTS'),
     methodSerializationOutputs,
   });
diff --git a/packages/react-native-codegen/src/generators/modules/Utils.js b/packages/react-native-codegen/src/generators/modules/Utils.js
index 872198ba2a4..e5b50c2ddd1 100644
--- a/packages/react-native-codegen/src/generators/modules/Utils.js
+++ b/packages/react-native-codegen/src/generators/modules/Utils.js
@@ -33,14 +33,14 @@ function createAliasResolver(aliasMap: NativeModuleAliasMap): AliasResolver {
 
 function getModules(
   schema: SchemaType,
-): $ReadOnly<{|[moduleName: string]: NativeModuleSchema|}> {
+): $ReadOnly<{|[hasteModuleName: string]: NativeModuleSchema|}> {
   return Object.keys(schema.modules).reduce<{|[string]: NativeModuleSchema|}>(
-    (modules, moduleName: string) => {
-      const module = schema.modules[moduleName];
+    (modules, hasteModuleName: string) => {
+      const module = schema.modules[hasteModuleName];
       if (module == null || module.type === 'Component') {
         return modules;
       }
-      modules[moduleName] = module;
+      modules[hasteModuleName] = module;
       return modules;
     },
     {},