@callstack/brownfield-cli 3.7.0 → 3.8.1

package/dist/navigation/generators/ts.js

@@ -1,17 +1,30 @@
 import path from 'node:path';
 import { createRequire } from 'node:module';
-export function generateTurboModuleSpec(methods) {
+function mapTypeForTurboSpec(typeText, options) {
+    if (typeText.startsWith('Promise<')) {
+        const inner = typeText.slice(8, -1);
+        return `Promise<${mapTypeForTurboSpec(inner, options)}>`;
+    }
+    if (options.modelTypeNames?.includes(typeText)) {
+        return 'Object';
+    }
+    return typeText;
+}
+export function generateTurboModuleSpec(methods, referencedTypeDeclarations = [], options = {}) {
     const methodSignatures = methods
         .map((method) => {
         const params = method.params
-            .map((param) => `${param.name}${param.optional ? '?' : ''}: ${param.type}`)
+            .map((param) => `${param.name}${param.optional ? '?' : ''}: ${mapTypeForTurboSpec(param.type, options)}`)
             .join(', ');
-        return `  ${method.name}(${params}): ${method.returnType};`;
+        return `  ${method.name}(${params}): ${mapTypeForTurboSpec(method.returnType, options)};`;
     })
         .join('\n');
+    const typeDeclarationsBlock = referencedTypeDeclarations.length === 0
+        ? ''
+        : `${referencedTypeDeclarations.map((entry) => entry.declaration).join('\n\n')}\n\n`;
     return `import { TurboModuleRegistry, type TurboModule } from 'react-native';
 
-export interface Spec extends TurboModule {
+${typeDeclarationsBlock}export interface Spec extends TurboModule {
 ${methodSignatures}
 }
 
@@ -20,7 +33,15 @@ export default TurboModuleRegistry.getEnforcing<Spec>(
 );
 `;
 }
-export function generateIndexTs(methods) {
+function buildTypeImportLine(referencedTypeDeclarations) {
+    if (referencedTypeDeclarations.length === 0) {
+        return '';
+    }
+    const names = referencedTypeDeclarations.map((entry) => entry.name).join(', ');
+    return `import type { ${names} } from './NativeBrownfieldNavigation';\n`;
+}
+export function generateIndexTs(methods, referencedTypeDeclarations = []) {
+    const typeImportLine = buildTypeImportLine(referencedTypeDeclarations);
     const functionImplementations = methods
         .map((method) => {
         const params = method.params
@@ -39,6 +60,7 @@ export function generateIndexTs(methods) {
     })
         .join(',\n');
     return `import NativeBrownfieldNavigation from './NativeBrownfieldNavigation';
+${typeImportLine}
 
 const BrownfieldNavigation = {
 ${functionImplementations},
@@ -78,7 +100,8 @@ export function transpileWithConsumerBabel(tsCode, projectRoot, packageRoot) {
     }
     return transformed.code;
 }
-export function generateIndexDts(methods) {
+export function generateIndexDts(methods, referencedTypeDeclarations = []) {
+    const typeImportLine = buildTypeImportLine(referencedTypeDeclarations);
     const methodSignatures = methods
         .map((method) => {
         const params = method.params
@@ -87,7 +110,7 @@ export function generateIndexDts(methods) {
         return `  ${method.name}: (${params}) => ${method.returnType};`;
     })
         .join('\n');
-    return `declare const BrownfieldNavigation: {
+    return `${typeImportLine}declare const BrownfieldNavigation: {
 ${methodSignatures}
 };
 

package/dist/navigation/parser.d.ts

@@ -1,3 +1,3 @@
-import type { MethodSignature } from './types.js';
-export declare function parseNavigationSpec(specPath: string): MethodSignature[];
+import type { ParsedNavigationSpec } from './types.js';
+export declare function parseNavigationSpec(specPath: string): ParsedNavigationSpec;
 //# sourceMappingURL=parser.d.ts.map

package/dist/navigation/parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/navigation/parser.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAe,eAAe,EAAE,MAAM,YAAY,CAAC;AAE/D,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,eAAe,EAAE,CAqCvE"}
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/navigation/parser.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAKV,oBAAoB,EAErB,MAAM,YAAY,CAAC;AAkCpB,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,oBAAoB,CA4G1E"}

package/dist/navigation/parser.js

@@ -1,5 +1,34 @@
 import fs from 'node:fs';
 import { Project } from 'ts-morph';
+import { Node } from 'ts-morph';
+const SKIP_TYPE_TOKENS = new Set([
+    'Array',
+    'Date',
+    'Map',
+    'Object',
+    'Promise',
+    'ReadonlyArray',
+    'Record',
+    'Set',
+    'any',
+    'boolean',
+    'false',
+    'null',
+    'number',
+    'object',
+    'string',
+    'true',
+    'undefined',
+    'unknown',
+    'void',
+]);
+function collectReferencedTypesFromText(typeText) {
+    const matches = typeText.match(/\b[A-Za-z_]\w*\b/g);
+    if (!matches) {
+        return [];
+    }
+    return matches.filter((match) => !SKIP_TYPE_TOKENS.has(match));
+}
 export function parseNavigationSpec(specPath) {
     if (!fs.existsSync(specPath)) {
         throw new Error(`Spec file not found: ${specPath}`);
@@ -11,7 +40,7 @@ export function parseNavigationSpec(specPath) {
     if (!specInterface) {
         throw new Error('Could not find BrownfieldNavigationSpec or Spec interface in spec file');
     }
-    return specInterface.getMethods().map((method) => {
+    const methods = specInterface.getMethods().map((method) => {
         const name = method.getName();
         const params = method.getParameters().map((param) => {
             const typeNode = param.getTypeNode();
@@ -30,4 +59,84 @@ export function parseNavigationSpec(specPath) {
             isAsync: returnType.startsWith('Promise<'),
         };
     });
+    const declarationNodes = [
+        ...sourceFile.getTypeAliases(),
+        ...sourceFile.getInterfaces(),
+    ].filter((node) => {
+        const nodeName = node.getName();
+        return nodeName !== 'BrownfieldNavigationSpec' && nodeName !== 'Spec';
+    });
+    const declarationByName = new Map(declarationNodes.map((node) => {
+        const declarationText = node.getText();
+        const normalizedDeclaration = node.isExported()
+            ? declarationText
+            : `export ${declarationText}`;
+        return [node.getName(), normalizedDeclaration];
+    }));
+    const referencedTypeNames = new Set();
+    for (const method of methods) {
+        for (const typeText of [
+            method.returnType,
+            ...method.params.map((param) => param.type),
+        ]) {
+            for (const typeName of collectReferencedTypesFromText(typeText)) {
+                referencedTypeNames.add(typeName);
+            }
+        }
+    }
+    const referencedTypeDeclarations = [];
+    const modelDefinitions = [];
+    const addedTypeNames = new Set();
+    const queue = [...referencedTypeNames];
+    while (queue.length > 0) {
+        const typeName = queue.shift();
+        if (!typeName || addedTypeNames.has(typeName)) {
+            continue;
+        }
+        const declaration = declarationByName.get(typeName);
+        if (!declaration) {
+            continue;
+        }
+        addedTypeNames.add(typeName);
+        referencedTypeDeclarations.push({ name: typeName, declaration });
+        const declarationNode = declarationNodes.find((node) => node.getName() === typeName);
+        if (declarationNode) {
+            const fields = extractModelFields(declarationNode);
+            if (fields.length > 0) {
+                modelDefinitions.push({ name: typeName, fields });
+            }
+        }
+        for (const nestedTypeName of collectReferencedTypesFromText(declaration)) {
+            if (!addedTypeNames.has(nestedTypeName) &&
+                declarationByName.has(nestedTypeName)) {
+                queue.push(nestedTypeName);
+            }
+        }
+    }
+    return {
+        methods,
+        referencedTypeDeclarations,
+        modelDefinitions,
+    };
+}
+function extractModelFields(node) {
+    if (Node.isInterfaceDeclaration(node)) {
+        return node.getProperties().map((property) => ({
+            name: property.getName(),
+            type: property.getTypeNode()?.getText() ?? 'unknown',
+            optional: property.hasQuestionToken(),
+        }));
+    }
+    if (Node.isTypeAliasDeclaration(node)) {
+        const typeNode = node.getTypeNode();
+        if (!typeNode || !Node.isTypeLiteral(typeNode)) {
+            return [];
+        }
+        return typeNode.getProperties().map((property) => ({
+            name: property.getName(),
+            type: property.getTypeNode()?.getText() ?? 'unknown',
+            optional: property.hasQuestionToken(),
+        }));
+    }
+    return [];
 }

package/dist/navigation/runner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../src/navigation/runner.ts"],"names":[],"mappings":"AA2BA,UAAU,2BAA2B;IACnC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAgLD,wBAAsB,oBAAoB,CAAC,EACzC,QAAQ,EACR,MAAc,EACd,WAA2B,GAC5B,EAAE,2BAA2B,GAAG,OAAO,CAAC,IAAI,CAAC,CA8D7C"}
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../src/navigation/runner.ts"],"names":[],"mappings":"AA2BA,UAAU,2BAA2B;IACnC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAgLD,wBAAsB,oBAAoB,CAAC,EACzC,QAAQ,EACR,MAAc,EACd,WAA2B,GAC5B,EAAE,2BAA2B,GAAG,OAAO,CAAC,IAAI,CAAC,CA0E7C"}

package/dist/navigation/runner.js

@@ -88,28 +88,39 @@ export async function runNavigationCodegen({ specPath, dryRun = false, projectRo
     }
     intro(`Running Brownfield Navigation codegen`);
     logger.info(`Parsing spec file: ${resolvedSpecPath}`);
-    const methods = parseNavigationSpec(resolvedSpecPath);
+    const { methods, referencedTypeDeclarations, modelDefinitions } = parseNavigationSpec(resolvedSpecPath);
     if (methods.length === 0) {
         throw new Error('No methods found in spec file');
     }
     logger.info(`Found ${methods.length} method${methods.length === 1 ? '' : 's'}: ${methods.map((method) => method.name).join(', ')}`);
     const packageRoot = getNavigationPackagePath(projectRoot);
     const androidJavaPackageName = DEFAULT_ANDROID_JAVA_PACKAGE;
-    const indexTs = generateIndexTs(methods);
+    const indexTs = generateIndexTs(methods, referencedTypeDeclarations);
     const models = await generateNavigationModels({
         specPath: resolvedSpecPath,
         methods,
         kotlinPackageName: androidJavaPackageName,
+        modelDefinitions,
     });
     const artifacts = {
-        turboModuleSpec: generateTurboModuleSpec(methods),
+        turboModuleSpec: generateTurboModuleSpec(methods, referencedTypeDeclarations, {
+            modelTypeNames: models.modelTypeNames,
+        }),
         indexTs,
         indexJs: transpileWithConsumerBabel(indexTs, projectRoot, packageRoot),
-        indexDts: generateIndexDts(methods),
-        swiftDelegate: generateSwiftDelegate(methods),
-        objcImplementation: generateObjCImplementation(methods),
-        kotlinDelegate: generateKotlinDelegate(methods, androidJavaPackageName),
-        kotlinModule: generateKotlinModule(methods, androidJavaPackageName),
+        indexDts: generateIndexDts(methods, referencedTypeDeclarations),
+        swiftDelegate: generateSwiftDelegate(methods, {
+            modelTypeNames: models.modelTypeNames,
+        }),
+        objcImplementation: generateObjCImplementation(methods, {
+            modelTypeNames: models.modelTypeNames,
+        }),
+        kotlinDelegate: generateKotlinDelegate(methods, androidJavaPackageName, {
+            modelTypeNames: models.modelTypeNames,
+        }),
+        kotlinModule: generateKotlinModule(methods, androidJavaPackageName, {
+            modelTypeNames: models.modelTypeNames,
+        }),
     };
     if (models.modelTypeNames.length > 0) {
         logger.info(`Generating quicktype models for types: ${models.modelTypeNames.join(', ')}`);

package/dist/navigation/types.d.ts

@@ -9,6 +9,24 @@ export interface MethodSignature {
     returnType: string;
     isAsync: boolean;
 }
+export interface TypeDeclaration {
+    name: string;
+    declaration: string;
+}
+export interface ModelFieldDefinition {
+    name: string;
+    type: string;
+    optional: boolean;
+}
+export interface ModelDefinition {
+    name: string;
+    fields: ModelFieldDefinition[];
+}
+export interface ParsedNavigationSpec {
+    methods: MethodSignature[];
+    referencedTypeDeclarations: TypeDeclaration[];
+    modelDefinitions: ModelDefinition[];
+}
 export interface GeneratedNavigationArtifacts {
     turboModuleSpec: string;
     indexTs: string;

package/dist/navigation/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/navigation/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,WAAW,EAAE,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,4BAA4B;IAC3C,eAAe,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/navigation/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,WAAW,EAAE,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,oBAAoB,EAAE,CAAC;CAChC;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,0BAA0B,EAAE,eAAe,EAAE,CAAC;IAC9C,gBAAgB,EAAE,eAAe,EAAE,CAAC;CACrC;AAED,MAAM,WAAW,4BAA4B;IAC3C,eAAe,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@callstack/brownfield-cli",
-  "version": "3.7.0",
+  "version": "3.8.1",
   "license": "MIT",
   "author": "Artur Morys-Magiera <artus9033@gmail.com>",
   "bin": {

package/src/navigation/generators/android.ts

@@ -8,10 +8,19 @@ const TS_TO_KOTLIN_TYPE: Record<string, string> = {
   Object: 'ReadableMap',
 };
 
-function mapTsTypeToKotlin(tsType: string, optional: boolean = false): string {
+interface KotlinTypeMappingOptions {
+  modelTypeNames?: string[];
+}
+
+function mapTsTypeToKotlin(
+  tsType: string,
+  optional: boolean = false,
+  options: KotlinTypeMappingOptions = {},
+  layer: 'delegate' | 'module' = 'delegate'
+): string {
   if (tsType.startsWith('Promise<')) {
     const inner = tsType.slice(8, -1);
-    return mapTsTypeToKotlin(inner, optional);
+    return mapTsTypeToKotlin(inner, optional, options, layer);
   }
 
   const mapped = TS_TO_KOTLIN_TYPE[tsType];
@@ -19,25 +28,33 @@ function mapTsTypeToKotlin(tsType: string, optional: boolean = false): string {
     return optional ? `${mapped}?` : mapped;
   }
 
+  if (options.modelTypeNames?.includes(tsType)) {
+    if (layer === 'module') {
+      return optional ? 'ReadableMap?' : 'ReadableMap';
+    }
+    return optional ? `${tsType}?` : tsType;
+  }
+
   return optional ? 'Any?' : 'Any';
 }
 
 export function generateKotlinDelegate(
   methods: MethodSignature[],
-  kotlinPackageName: string
+  kotlinPackageName: string,
+  options: KotlinTypeMappingOptions = {}
 ): string {
   const methodSignatures = methods
     .map((method) => {
       const params = method.params
         .map(
           (param) =>
-            `${param.name}: ${mapTsTypeToKotlin(param.type, param.optional)}`
+            `${param.name}: ${mapTsTypeToKotlin(param.type, param.optional, options)}`
         )
         .join(', ');
       const returnType =
         method.returnType === 'void'
           ? ''
-          : `: ${mapTsTypeToKotlin(method.returnType, false)}`;
+          : `: ${mapTsTypeToKotlin(method.returnType, false, options, 'delegate')}`;
       return `  fun ${method.name}(${params})${returnType}`;
     })
     .join('\n');
@@ -52,20 +69,24 @@ ${methodSignatures}
 
 export function generateKotlinModule(
   methods: MethodSignature[],
-  kotlinPackageName: string
+  kotlinPackageName: string,
+  options: KotlinTypeMappingOptions = {}
 ): string {
   const hasAsyncMethod = methods.some((method) => method.isAsync);
   const hasObjectType = methods.some(
     (method) =>
       method.returnType.includes('Object') ||
-      method.params.some((param) => param.type === 'Object')
+      method.params.some(
+        (param) =>
+          param.type === 'Object' || options.modelTypeNames?.includes(param.type)
+      )
   );
 
   const methodImplementations = methods
     .map((method) =>
       method.isAsync
-        ? generateAsyncKotlinMethod(method)
-        : generateSyncKotlinMethod(method)
+        ? generateAsyncKotlinMethod(method, options)
+        : generateSyncKotlinMethod(method, options)
     )
     .join('\n\n');
 
@@ -88,32 +109,61 @@ ${methodImplementations}
 `;
 }
 
-function generateSyncKotlinMethod(method: MethodSignature): string {
+function generateSyncKotlinMethod(
+  method: MethodSignature,
+  options: KotlinTypeMappingOptions = {}
+): string {
   const params = method.params
-    .map((param) => `${param.name}: ${mapTsTypeToKotlin(param.type, param.optional)}`)
+    .map(
+      (param) =>
+        `${param.name}: ${mapTsTypeToKotlin(param.type, param.optional, options, 'module')}`
+    )
+    .join(', ');
+  const preparedParams: string[] = [];
+  const args = method.params
+    .map((param) => {
+      if (options.modelTypeNames?.includes(param.type)) {
+        const convertedName = `${param.name}Model`;
+        preparedParams.push(
+          `    val ${convertedName} = ${param.name}${
+            param.optional
+              ? `?.let(::to${param.type})`
+              : `.let(::to${param.type})`
+          }`
+        );
+        return convertedName;
+      }
+      return param.name;
+    })
     .join(', ');
-  const args = method.params.map((param) => param.name).join(', ');
 
   const signature = `  @ReactMethod\n  override fun ${method.name}(${params})${
     method.returnType === 'void'
       ? ''
-      : `: ${mapTsTypeToKotlin(method.returnType, false)}`
+      : `: ${mapTsTypeToKotlin(method.returnType, false, options, 'module')}`
   }`;
+  const preparedPrefix = preparedParams.length > 0 ? `${preparedParams.join('\n')}\n` : '';
 
   if (method.returnType === 'void') {
     return `${signature} {
-    BrownfieldNavigationManager.getDelegate().${method.name}(${args})
+${preparedPrefix}    BrownfieldNavigationManager.getDelegate().${method.name}(${args})
   }`;
   }
 
   return `${signature} {
-    return BrownfieldNavigationManager.getDelegate().${method.name}(${args})
+${preparedPrefix}    return BrownfieldNavigationManager.getDelegate().${method.name}(${args})
   }`;
 }
 
-function generateAsyncKotlinMethod(method: MethodSignature): string {
+function generateAsyncKotlinMethod(
+  method: MethodSignature,
+  options: KotlinTypeMappingOptions = {}
+): string {
   const paramsWithTypes = method.params
-    .map((param) => `${param.name}: ${mapTsTypeToKotlin(param.type, param.optional)}`)
+    .map(
+      (param) =>
+        `${param.name}: ${mapTsTypeToKotlin(param.type, param.optional, options, 'module')}`
+    )
     .join(', ');
   const params =
     paramsWithTypes.length > 0

package/src/navigation/generators/ios.ts

@@ -16,11 +16,23 @@ const TS_TO_SWIFT_TYPE: Record<string, string> = {
   Object: '[String: Any]',
 };
 
-function mapTsTypeToObjC(tsType: string, nullable: boolean = false): string {
+interface ObjCTypeMappingOptions {
+  modelTypeNames?: string[];
+}
+
+function mapTsTypeToObjC(
+  tsType: string,
+  nullable: boolean = false,
+  options: ObjCTypeMappingOptions = {}
+): string {
   if (tsType.startsWith('Promise<')) {
     return 'void';
   }
 
+  if (options.modelTypeNames?.includes(tsType)) {
+    return nullable ? 'NSDictionary * _Nullable' : 'NSDictionary *';
+  }
+
   const mapped = TS_TO_OBJC_TYPE[tsType];
   if (mapped) {
     if (nullable && mapped.includes('*')) {
@@ -32,10 +44,20 @@ function mapTsTypeToObjC(tsType: string, nullable: boolean = false): string {
   return nullable ? 'id _Nullable' : 'id';
 }
 
-function mapTsTypeToSwift(tsType: string, optional: boolean = false): string {
+interface SwiftTypeMappingOptions {
+  modelTypeNames?: string[];
+}
+
+interface ObjCGenerationOptions extends ObjCTypeMappingOptions {}
+
+function mapTsTypeToSwift(
+  tsType: string,
+  optional: boolean = false,
+  options: SwiftTypeMappingOptions = {}
+): string {
   if (tsType.startsWith('Promise<')) {
     const inner = tsType.slice(8, -1);
-    return mapTsTypeToSwift(inner, optional);
+    return mapTsTypeToSwift(inner, optional, options);
   }
 
   const mapped = TS_TO_SWIFT_TYPE[tsType];
@@ -43,15 +65,22 @@ function mapTsTypeToSwift(tsType: string, optional: boolean = false): string {
     return optional ? `${mapped}?` : mapped;
   }
 
+  if (options.modelTypeNames?.includes(tsType)) {
+    return optional ? `${tsType}?` : tsType;
+  }
+
   return optional ? 'Any?' : 'Any';
 }
 
-export function generateSwiftDelegate(methods: MethodSignature[]): string {
+export function generateSwiftDelegate(
+  methods: MethodSignature[],
+  options: SwiftTypeMappingOptions = {}
+): string {
   const protocolMethods = methods
     .map((method) => {
       const params = method.params
         .map((param, index) => {
-          const swiftType = mapTsTypeToSwift(param.type, param.optional);
+          const swiftType = mapTsTypeToSwift(param.type, param.optional, options);
           const label = index === 0 ? '_' : param.name;
           return `${label} ${param.name}: ${swiftType}`;
         })
@@ -60,7 +89,7 @@ export function generateSwiftDelegate(methods: MethodSignature[]): string {
       const returnType =
         method.returnType === 'void'
           ? ''
-          : ` -> ${mapTsTypeToSwift(method.returnType, false)}`;
+          : ` -> ${mapTsTypeToSwift(method.returnType, false, options)}`;
 
       return `    @objc func ${method.name}(${params})${returnType}`;
     })
@@ -74,10 +103,15 @@ ${protocolMethods}
 `;
 }
 
-export function generateObjCImplementation(methods: MethodSignature[]): string {
+export function generateObjCImplementation(
+  methods: MethodSignature[],
+  options: ObjCGenerationOptions = {}
+): string {
   const methodImplementations = methods
     .map((method) =>
-      method.isAsync ? generateAsyncObjCMethod(method) : generateSyncObjCMethod(method)
+      method.isAsync
+        ? generateAsyncObjCMethod(method, options)
+        : generateSyncObjCMethod(method, options)
     )
     .join('\n\n');
 
@@ -108,38 +142,61 @@ ${methodImplementations}
 `;
 }
 
-function generateSyncObjCMethod(method: MethodSignature): string {
+function generateSyncObjCMethod(
+  method: MethodSignature,
+  options: ObjCGenerationOptions
+): string {
   const { name, params, returnType } = method;
 
-  let signature = `- (${mapTsTypeToObjC(returnType)})${name}`;
+  let signature = `- (${mapTsTypeToObjC(returnType, false, options)})${name}`;
   if (params.length > 0) {
     signature += params
       .map((param, index) => {
         const prefix = index === 0 ? ':' : ` ${param.name}:`;
-        return `${prefix}(${mapTsTypeToObjC(param.type, param.optional)})${param.name}`;
+        return `${prefix}(${mapTsTypeToObjC(param.type, param.optional, options)})${param.name}`;
       })
       .join('');
   }
 
+  const preparedParams: string[] = [];
+  const delegateArgs: string[] = [];
+  for (const param of params) {
+    if (options.modelTypeNames?.includes(param.type)) {
+      const convertedParamName = `${param.name}Model`;
+      preparedParams.push(
+        `${param.type} *${convertedParamName} = ${param.name} == nil ? nil : [${param.type} fromDictionary:${param.name}];`
+      );
+      delegateArgs.push(convertedParamName);
+    } else {
+      delegateArgs.push(param.name);
+    }
+  }
+
   let delegateCall = `[[[BrownfieldNavigationManager shared] getDelegate] ${name}`;
-  if (params.length > 0) {
-    delegateCall += params
-      .map((param, index) => {
+  if (delegateArgs.length > 0) {
+    delegateCall += delegateArgs
+      .map((argName, index) => {
+        const param = params[index];
         const label = index === 0 ? '' : param.name;
-        return `${label}:${param.name}`;
+        return `${label}:${argName}`;
       })
       .join(' ');
   }
   delegateCall += ']';
 
   const returnPrefix = returnType === 'void' ? '' : 'return ';
+  const preparedLines = preparedParams.map((line) => `    ${line}`).join('\n');
+  const bodyPrefix = preparedLines.length > 0 ? `${preparedLines}\n` : '';
 
   return `${signature} {
-    ${returnPrefix}${delegateCall};
+${bodyPrefix}    ${returnPrefix}${delegateCall};
 }`;
 }
 
-function generateAsyncObjCMethod(method: MethodSignature): string {
+function generateAsyncObjCMethod(
+  method: MethodSignature,
+  options: ObjCGenerationOptions
+): string {
   const { name, params } = method;
 
   let signature = `- (void)${name}`;
@@ -158,7 +215,7 @@ function generateAsyncObjCMethod(method: MethodSignature): string {
           ? 'RCTPromiseResolveBlock'
           : param.type === 'RCTPromiseRejectBlock'
             ? 'RCTPromiseRejectBlock'
-            : mapTsTypeToObjC(param.type, param.optional);
+            : mapTsTypeToObjC(param.type, param.optional, options);
       return `${prefix}(${type})${param.name}`;
     })
     .join(' ');