@@ -46,6 +46,10 @@ export interface VoidTypeAnnotation {
   readonly type: 'VoidTypeAnnotation';
 }
 
+export interface ArrayBufferTypeAnnotation {
+  readonly type: 'ArrayBufferTypeAnnotation';
+}
+
 export interface BooleanLiteralTypeAnnotation {
   readonly type: 'BooleanLiteralTypeAnnotation';
   readonly value: boolean;
@@ -417,7 +421,8 @@ export type NativeModuleEventEmitterTypeAnnotation =
   | ArrayTypeAnnotation<NativeModuleEventEmitterBaseTypeAnnotation>;
 
 export type NativeModuleBaseTypeAnnotation =
-  NativeModuleStringTypeAnnotation
+  ArrayBufferTypeAnnotation
+  | NativeModuleStringTypeAnnotation
   | StringLiteralTypeAnnotation
   | StringLiteralUnionTypeAnnotation
   | NativeModuleNumberTypeAnnotation
 
@@ -68,6 +68,10 @@ export type VoidTypeAnnotation = Readonly<{
   type: 'VoidTypeAnnotation',
 }>;
 
+export type ArrayBufferTypeAnnotation = Readonly<{
+  type: 'ArrayBufferTypeAnnotation',
+}>;
+
 export type ObjectTypeAnnotation<+T> = Readonly<{
   type: 'ObjectTypeAnnotation',
   properties: ReadonlyArray<NamedShape<T>>,
@@ -411,6 +415,7 @@ export type NativeModuleEventEmitterTypeAnnotation =
   | ArrayTypeAnnotation<NativeModuleEventEmitterBaseTypeAnnotation>;
 
 export type NativeModuleBaseTypeAnnotation =
+  | ArrayBufferTypeAnnotation
   | StringTypeAnnotation
   | StringLiteralTypeAnnotation
   | StringLiteralUnionTypeAnnotation
 
@@ -146,6 +146,8 @@ function serializeArg(
       return wrap(val => `${val}.asObject(rt)`);
     case 'MixedTypeAnnotation':
       return wrap(val => `jsi::Value(rt, ${val})`);
+    case 'ArrayBufferTypeAnnotation':
+      return wrap(val => `${val}.asObject(rt).getArrayBuffer(rt)`);
     default:
       realTypeAnnotation.type as empty;
       throw new Error(
@@ -307,6 +309,8 @@ function translatePrimitiveJSTypeToCpp(
       return wrapOptional('jsi::Value', isRequired);
     case 'MixedTypeAnnotation':
       return wrapOptional('jsi::Value', isRequired);
+    case 'ArrayBufferTypeAnnotation':
+      return wrapOptional('jsi::ArrayBuffer', isRequired);
     default:
       realTypeAnnotation.type as empty;
       throw new Error(createErrorMessage(realTypeAnnotation.type));
 
@@ -267,6 +267,10 @@ function translateFunctionParamToJavaType(
     case 'FunctionTypeAnnotation':
       imports.add('com.facebook.react.bridge.Callback');
       return wrapOptional('Callback', isRequired);
+    case 'ArrayBufferTypeAnnotation':
+      throw new Error(
+        `${createErrorMessage(realTypeAnnotation.type)} ArrayBuffer is only supported for C++ TurboModules.`,
+      );
     default:
       realTypeAnnotation.type as 'MixedTypeAnnotation';
       throw new Error(createErrorMessage(realTypeAnnotation.type));
@@ -361,6 +365,10 @@ function translateFunctionReturnTypeToJavaType(
     case 'ArrayTypeAnnotation':
       imports.add('com.facebook.react.bridge.WritableArray');
       return wrapOptional('WritableArray', isRequired);
+    case 'ArrayBufferTypeAnnotation':
+      throw new Error(
+        `${createErrorMessage(realTypeAnnotation.type)} ArrayBuffer is only supported for C++ TurboModules.`,
+      );
     default:
       realTypeAnnotation.type as 'MixedTypeAnnotation';
       throw new Error(createErrorMessage(realTypeAnnotation.type));
@@ -443,6 +451,10 @@ function getFalsyReturnStatementFromReturnType(
       return 'return null;';
     case 'ArrayTypeAnnotation':
       return 'return null;';
+    case 'ArrayBufferTypeAnnotation':
+      throw new Error(
+        `${createErrorMessage(realTypeAnnotation.type)} ArrayBuffer is only supported for C++ TurboModules.`,
+      );
     default:
       realTypeAnnotation.type as 'MixedTypeAnnotation';
       throw new Error(createErrorMessage(realTypeAnnotation.type));
 
@@ -216,6 +216,8 @@ function translateReturnTypeToKind(
       return 'ObjectKind';
     case 'ArrayTypeAnnotation':
       return 'ArrayKind';
+    case 'ArrayBufferTypeAnnotation':
+      throw new Error('ArrayBuffer is only supported for C++ TurboModules.');
     default:
       realTypeAnnotation.type as 'MixedTypeAnnotation';
       throw new Error(
@@ -303,6 +305,8 @@ function translateParamTypeToJniType(
       return 'Lcom/facebook/react/bridge/ReadableArray;';
     case 'FunctionTypeAnnotation':
       return 'Lcom/facebook/react/bridge/Callback;';
+    case 'ArrayBufferTypeAnnotation':
+      throw new Error('ArrayBuffer is only supported for C++ TurboModules.');
     default:
       realTypeAnnotation.type as 'MixedTypeAnnotation';
       throw new Error(
@@ -387,6 +391,8 @@ function translateReturnTypeToJniType(
       return 'Lcom/facebook/react/bridge/WritableMap;';
     case 'ArrayTypeAnnotation':
       return 'Lcom/facebook/react/bridge/WritableArray;';
+    case 'ArrayBufferTypeAnnotation':
+      throw new Error('ArrayBuffer is only supported for C++ TurboModules.');
     default:
       realTypeAnnotation.type as 'MixedTypeAnnotation';
       throw new Error(
 
@@ -132,6 +132,10 @@ class StructCollector {
         return wrapNullable(nullable, typeAnnotation);
       case 'MixedTypeAnnotation':
         throw new Error('Mixed types are unsupported in structs');
+      case 'ArrayBufferTypeAnnotation':
+        throw new Error(
+          'ArrayBuffer is unsupported in TurboModule struct types.',
+        );
       case 'UnionTypeAnnotation':
         try {
           const validUnionType = parseValidUnionType(typeAnnotation);
 
@@ -387,6 +387,10 @@ function getReturnObjCType(
       }
     case 'GenericObjectTypeAnnotation':
       return wrapOptional('NSDictionary *', isRequired);
+    case 'ArrayBufferTypeAnnotation':
+      throw new Error(
+        `Unsupported return type for ${methodName}: ArrayBuffer is only supported for C++ TurboModules.`,
+      );
     default:
       typeAnnotation.type as 'MixedTypeAnnotation';
       throw new Error(
@@ -459,6 +463,10 @@ function getReturnJSType(
           validUnionType as empty;
           throw new Error(`Unsupported union member types`);
       }
+    case 'ArrayBufferTypeAnnotation':
+      throw new Error(
+        `Unsupported return type for ${methodName}: ArrayBuffer is only supported for C++ TurboModules.`,
+      );
     default:
       typeAnnotation.type as 'MixedTypeAnnotation';
       throw new Error(
 
@@ -2600,6 +2600,89 @@ const CXX_ONLY_NATIVE_MODULES: SchemaType = {
   },
 };
 
+const ARRAY_BUFFER_NATIVE_MODULE: SchemaType = {
+  modules: {
+    NativeSampleTurboModule: {
+      type: 'NativeModule',
+      aliasMap: {},
+      enumMap: {},
+      spec: {
+        eventEmitters: [],
+        methods: [
+          {
+            name: 'getArrayBuffer',
+            optional: false,
+            typeAnnotation: {
+              type: 'FunctionTypeAnnotation',
+              returnTypeAnnotation: {
+                type: 'ArrayBufferTypeAnnotation',
+              },
+              params: [],
+            },
+          },
+          {
+            name: 'voidArrayBuffer',
+            optional: false,
+            typeAnnotation: {
+              type: 'FunctionTypeAnnotation',
+              returnTypeAnnotation: {
+                type: 'VoidTypeAnnotation',
+              },
+              params: [
+                {
+                  name: 'arg',
+                  optional: false,
+                  typeAnnotation: {
+                    type: 'ArrayBufferTypeAnnotation',
+                  },
+                },
+              ],
+            },
+          },
+          {
+            name: 'voidNullableArrayBuffer',
+            optional: false,
+            typeAnnotation: {
+              type: 'FunctionTypeAnnotation',
+              returnTypeAnnotation: {
+                type: 'VoidTypeAnnotation',
+              },
+              params: [
+                {
+                  name: 'arg',
+                  optional: false,
+                  typeAnnotation: {
+                    type: 'NullableTypeAnnotation',
+                    typeAnnotation: {
+                      type: 'ArrayBufferTypeAnnotation',
+                    },
+                  },
+                },
+              ],
+            },
+          },
+          {
+            name: 'promiseArrayBuffer',
+            optional: false,
+            typeAnnotation: {
+              type: 'FunctionTypeAnnotation',
+              returnTypeAnnotation: {
+                type: 'PromiseTypeAnnotation',
+                elementType: {
+                  type: 'ArrayBufferTypeAnnotation',
+                },
+              },
+              params: [],
+            },
+          },
+        ],
+      },
+      moduleName: 'SampleTurboModule',
+      excludedPlatforms: ['iOS', 'android'],
+    },
+  },
+};
+
 const SAMPLE_WITH_UPPERCASE_NAME: SchemaType = {
   modules: {
     NativeSampleTurboModule: {
@@ -2793,6 +2876,7 @@ const STRING_LITERALS: SchemaType = {
 };
 
 module.exports = {
+  array_buffer_native_module: ARRAY_BUFFER_NATIVE_MODULE,
   complex_objects: COMPLEX_OBJECTS,
   two_modules_different_files: TWO_MODULES_DIFFERENT_FILES,
   empty_native_modules: EMPTY_NATIVE_MODULES,
 
@@ -38,6 +38,75 @@ private:
 }
 `;
 
+exports[`GenerateModuleH can generate fixture array_buffer_native_module 1`] = `
+Map {
+  "array_buffer_native_moduleJSI.h" => "/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleH.js
+ */
+
+#pragma once
+
+#include <ReactCommon/TurboModule.h>
+#include <react/bridging/Bridging.h>
+
+namespace facebook::react {
+
+
+template <typename T>
+class JSI_EXPORT NativeSampleTurboModuleCxxSpec : public TurboModule {
+public:
+  static constexpr std::string_view kModuleName = \\"SampleTurboModule\\";
+
+protected:
+  NativeSampleTurboModuleCxxSpec(std::shared_ptr<CallInvoker> jsInvoker) : TurboModule(std::string{NativeSampleTurboModuleCxxSpec::kModuleName}, jsInvoker) {
+    methodMap_[\\"getArrayBuffer\\"] = MethodMetadata {.argCount = 0, .invoker = __getArrayBuffer};
+    methodMap_[\\"voidArrayBuffer\\"] = MethodMetadata {.argCount = 1, .invoker = __voidArrayBuffer};
+    methodMap_[\\"voidNullableArrayBuffer\\"] = MethodMetadata {.argCount = 1, .invoker = __voidNullableArrayBuffer};
+    methodMap_[\\"promiseArrayBuffer\\"] = MethodMetadata {.argCount = 0, .invoker = __promiseArrayBuffer};
+  }
+  
+private:
+  static jsi::Value __getArrayBuffer(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* /*args*/, size_t /*count*/) {
+    static_assert(
+      bridging::getParameterCount(&T::getArrayBuffer) == 1,
+      \\"Expected getArrayBuffer(...) to have 1 parameters\\");
+    return bridging::callFromJs<jsi::ArrayBuffer>(rt, &T::getArrayBuffer,  static_cast<NativeSampleTurboModuleCxxSpec*>(&turboModule)->jsInvoker_, static_cast<T*>(&turboModule));
+  }
+
+  static jsi::Value __voidArrayBuffer(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
+    static_assert(
+      bridging::getParameterCount(&T::voidArrayBuffer) == 2,
+      \\"Expected voidArrayBuffer(...) to have 2 parameters\\");
+    bridging::callFromJs<void>(rt, &T::voidArrayBuffer,  static_cast<NativeSampleTurboModuleCxxSpec*>(&turboModule)->jsInvoker_, static_cast<T*>(&turboModule),
+      count <= 0 ? throw jsi::JSError(rt, \\"Expected argument in position 0 to be passed\\") : args[0].asObject(rt).getArrayBuffer(rt));return jsi::Value::undefined();
+  }
+
+  static jsi::Value __voidNullableArrayBuffer(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
+    static_assert(
+      bridging::getParameterCount(&T::voidNullableArrayBuffer) == 2,
+      \\"Expected voidNullableArrayBuffer(...) to have 2 parameters\\");
+    bridging::callFromJs<void>(rt, &T::voidNullableArrayBuffer,  static_cast<NativeSampleTurboModuleCxxSpec*>(&turboModule)->jsInvoker_, static_cast<T*>(&turboModule),
+      count <= 0 || args[0].isNull() || args[0].isUndefined() ? std::nullopt : std::make_optional(args[0].asObject(rt).getArrayBuffer(rt)));return jsi::Value::undefined();
+  }
+
+  static jsi::Value __promiseArrayBuffer(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* /*args*/, size_t /*count*/) {
+    static_assert(
+      bridging::getParameterCount(&T::promiseArrayBuffer) == 1,
+      \\"Expected promiseArrayBuffer(...) to have 1 parameters\\");
+    return bridging::callFromJs<jsi::Value>(rt, &T::promiseArrayBuffer,  static_cast<NativeSampleTurboModuleCxxSpec*>(&turboModule)->jsInvoker_, static_cast<T*>(&turboModule));
+  }
+};
+
+} // namespace facebook::react
+",
+}
+`;
+
 exports[`GenerateModuleH can generate fixture complex_objects 1`] = `
 Map {
   "complex_objectsJSI.h" => "/**
 
@@ -65,6 +65,47 @@ namespace facebook::react {
 }
 `;
 
+exports[`GenerateModuleHObjCpp can generate fixture array_buffer_native_module 1`] = `
+Map {
+  "array_buffer_native_module.h" => "/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleObjCpp
+ *
+ * We create an umbrella header (and corresponding implementation) here since
+ * Cxx compilation in BUCK has a limitation: source-code producing genrule()s
+ * must have a single output. More files => more genrule()s => slower builds.
+ */
+
+#ifndef __cplusplus
+#error This file must be compiled as Obj-C++. If you are importing it, you must change your file extension to .mm.
+#endif
+
+// Avoid multiple includes of array_buffer_native_module symbols
+#ifndef array_buffer_native_module_H
+#define array_buffer_native_module_H
+
+#import <Foundation/Foundation.h>
+#import <RCTRequired/RCTRequired.h>
+#import <RCTTypeSafety/RCTConvertHelpers.h>
+#import <RCTTypeSafety/RCTTypedModuleConstants.h>
+#import <React/RCTBridgeModule.h>
+#import <React/RCTCxxConvert.h>
+#import <React/RCTManagedPointer.h>
+#import <ReactCommon/RCTTurboModule.h>
+#import <optional>
+#import <vector>
+
+
+
+#endif // array_buffer_native_module_H
+",
+}
+`;
+
 exports[`GenerateModuleHObjCpp can generate fixture complex_objects 1`] = `
 Map {
   "complex_objects.h" => "/**