@callstack/brownfield-cli 3.11.0 → 3.13.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@callstack/brownfield-cli",
-  "version": "3.11.0",
+  "version": "3.13.0",
   "license": "MIT",
   "author": "Artur Morys-Magiera <artus9033@gmail.com>",
   "bin": {
@@ -37,6 +37,11 @@
       "types": "./dist/navigation/index.d.ts",
       "default": "./dist/navigation/index.js"
     },
+    "./types": {
+      "source": "./src/types.ts",
+      "types": "./dist/types.d.ts",
+      "default": "./dist/types.js"
+    },
     "./package.json": "./package.json"
   },
   "scripts": {
@@ -45,6 +50,7 @@
     "build:brownfield": "yarn run build",
     "build": "node -e \"const fs=require('fs'),p=require('path');const d=p.join('dist','index.d.ts');if(!fs.existsSync(d)){try{fs.unlinkSync('tsconfig.tsbuildinfo')}catch{}}\" && tsc -p tsconfig.json",
     "dev": "tsc -p tsconfig.json --watch",
+    "generate:schema": "ts-json-schema-generator --path src/types.ts --type BrownfieldConfig --out schema.json && prettier --write schema.json",
     "test": "vitest run"
   },
   "keywords": [
@@ -81,6 +87,7 @@
     "@rock-js/plugin-brownfield-android": "^0.13.3",
     "@rock-js/plugin-brownfield-ios": "^0.13.3",
     "@rock-js/tools": "^0.13.3",
+    "ajv": "^8.20.0",
     "commander": "^14.0.3",
     "quicktype-core": "^23.2.6",
     "quicktype-typescript-input": "^23.2.6",
@@ -100,6 +107,7 @@
     "eslint": "^9.39.3",
     "globals": "^17.3.0",
     "nodemon": "^3.1.14",
+    "ts-json-schema-generator": "^2.9.0",
     "typescript": "5.9.3",
     "vitest": "^4.1.4"
   },

package/src/brownfield/commands/packageAndroid.ts

@@ -15,16 +15,15 @@ import { runExpoPrebuildIfNeeded } from '../utils/expo.js';
 import { getProjectInfo } from '../utils/project.js';
 import { runBrownieCodegenIfApplicable } from '../../brownie/helpers/runBrownieCodegenIfApplicable.js';
 import { runNavigationCodegenIfApplicable } from '../../navigation/helpers/runNavigationCodegenIfApplicable.js';
+import { mergeBrownfieldConfigWithOptions } from '../../config.js';
 
 export const packageAndroidCommand = curryOptions(
   new Command('package:android').description('Build Android AAR'),
-  packageAarOptions.map((option) =>
-    option.name.startsWith('--variant')
-      ? { ...option, default: 'debug' }
-      : option
-  )
+  packageAarOptions
 ).action(
-  actionRunner(async (options: PackageAarFlags) => {
+  actionRunner(async (cliOptions: PackageAarFlags) => {
+    const options = mergeBrownfieldConfigWithOptions(cliOptions, 'android');
+
     const { projectRoot, platformConfig } = getProjectInfo('android');
     await runExpoPrebuildIfNeeded({
       projectRoot,

package/src/brownfield/commands/packageIos.ts

@@ -4,7 +4,6 @@ import path from 'node:path';
 import {
   getBuildOptions,
   mergeFrameworks,
-  type BuildFlags as AppleBuildFlags,
 } from '@rock-js/platform-apple-helpers';
 import { packageIosAction } from '@rock-js/plugin-brownfield-ios';
 import {
@@ -30,7 +29,9 @@ import { runNavigationCodegenIfApplicable } from '../../navigation/helpers/runNa
 import { copyDebugBundleToSimulatorSlice } from '../utils/copyDebugBundleToSimulatorSlice.js';
 import { resolvePackagedFrameworkName } from '../utils/resolvePackagedFrameworkName.js';
 import { stripFrameworkBinary } from '../utils/stripFrameworkBinary.js';
+import type { PackageIosOptions } from '../../types.js';
 import { createLocalSpmPackage } from '../utils/createLocalSpmPackage.js';
+import { mergeBrownfieldConfigWithOptions } from '../../config.js';
 
 /** Help text for `--use-prebuilt-rn-core` (keep in sync with docs/docs/docs/getting-started/ios.mdx, "React Native Prebuilts" section). */
 const USE_PREBUILT_RN_CORE_HELP =
@@ -69,13 +70,6 @@ function getPackagedFrameworkResolutionFailureMessage({
     : 'could not resolve the packaged framework output automatically; pass --scheme explicitly';
 }
 
-type PackageIosCliFlags = AppleBuildFlags & {
-  /** Set when `--use-prebuilt-rn-core` is passed; omitted when the flag is absent (Rock applies RN version defaults). */
-  usePrebuiltRnCore?: boolean;
-  /** When set, generate a local Swift Package Manager manifest next to the packaged XCFramework outputs. */
-  addSpmPackage?: boolean;
-};
-
 export const packageIosCommand = curryOptions(
   new Command('package:ios').description('Build iOS XCFramework'),
   getBuildOptions({ platformName: 'ios' }).map((option) =>
@@ -101,7 +95,9 @@ export const packageIosCommand = curryOptions(
     )
   )
   .action(
-    actionRunner(async (options: PackageIosCliFlags) => {
+    actionRunner(async (cliOptions: PackageIosOptions) => {
+      const options = mergeBrownfieldConfigWithOptions(cliOptions, 'ios');
+
       const { projectRoot, platformConfig, userConfig } = getProjectInfo('ios');
 
       const prebuiltRNCoreSupport = supportsPrebuiltRNCore({ projectRoot });
@@ -196,10 +192,12 @@ export const packageIosCommand = curryOptions(
 
       if (!frameworkName && options.addSpmPackage) {
         throw new RockError(
-          `Cannot generate local SPM package: ${getPackagedFrameworkResolutionFailureMessage({
-            resolution,
-            candidates,
-          })}`
+          `Cannot generate local SPM package: ${getPackagedFrameworkResolutionFailureMessage(
+            {
+              resolution,
+              candidates,
+            }
+          )}`
         );
       }
 
@@ -231,10 +229,12 @@ export const packageIosCommand = curryOptions(
         }
       } else if (configuration.includes('Debug')) {
         logger.warn(
-          `Skipping Debug simulator JS bundle copy: ${getPackagedFrameworkResolutionFailureMessage({
-            resolution,
-            candidates,
-          })}`
+          `Skipping Debug simulator JS bundle copy: ${getPackagedFrameworkResolutionFailureMessage(
+            {
+              resolution,
+              candidates,
+            }
+          )}`
         );
       }
 
@@ -326,7 +326,7 @@ export const packageIosCommand = curryOptions(
           `Add the local package folder in Xcode: ${colorLink(relativeToCwd(packageDir))}`
         );
         logger.info(
-          "In Xcode, choose File > Add Package Dependencies..., click Add Local..., and select that folder."
+          'In Xcode, choose File > Add Package Dependencies..., click Add Local..., and select that folder.'
         );
       }
     })

package/src/brownfield/commands/publishAndroid.ts

@@ -15,6 +15,7 @@ import { getProjectInfo } from '../utils/project.js';
 import { runExpoPrebuildIfNeeded } from '../utils/expo.js';
 import { runBrownieCodegenIfApplicable } from '../../brownie/helpers/runBrownieCodegenIfApplicable.js';
 import { runNavigationCodegenIfApplicable } from '../../navigation/helpers/runNavigationCodegenIfApplicable.js';
+import { mergeBrownfieldConfigWithOptions } from '../../config.js';
 
 export const publishAndroidCommand = curryOptions(
   new Command('publish:android').description(
@@ -22,7 +23,9 @@ export const publishAndroidCommand = curryOptions(
   ),
   publishLocalAarOptions
 ).action(
-  actionRunner(async (options: PublishLocalAarFlags) => {
+  actionRunner(async (cliOptions: PublishLocalAarFlags) => {
+    const options = mergeBrownfieldConfigWithOptions(cliOptions, 'android');
+
     const { projectRoot, platformConfig } = getProjectInfo('android');
     await runExpoPrebuildIfNeeded({
       projectRoot,

package/src/brownie/commands/codegen.ts

@@ -7,15 +7,15 @@ import { intro, logger, outro } from '@rock-js/tools';
 import { QuickTypeError } from 'quicktype-core';
 import { actionRunner } from '../../shared/index.js';
 import {
-  loadConfig,
   getSwiftOutputPath,
-  type BrownieConfig,
+  resolveBrownieCodegenConfig,
 } from '../config.js';
+import { findProjectRoot } from '../../brownfield/utils/paths.js';
 import { generateSwift } from '../generators/swift.js';
 import { generateKotlin } from '../generators/kotlin.js';
 import { discoverStores, type DiscoveredStore } from '../store-discovery.js';
-import type { Platform } from '../types.js';
 import { NoBrownieStoresError } from '../errors/NoBrownieStoresError.js';
+import type { BrownieConfig, Platform } from '../../types.js';
 
 function getOutputPath(dir: string, name: string, ext: string): string {
   return path.join(dir, `${name}.${ext}`);
@@ -34,7 +34,8 @@ async function generateForStore(
   store: DiscoveredStore,
   config: BrownieConfig,
   platforms: Platform[],
-  showLabel: boolean
+  showLabel: boolean,
+  projectRoot: string
 ): Promise<void> {
   const { name, schemaPath } = store;
   const storeLabel = showLabel ? ` [${name}]` : '';
@@ -45,7 +46,7 @@ async function generateForStore(
     let outputPath: string;
 
     if (p === 'swift') {
-      const swiftOutputDir = getSwiftOutputPath();
+      const swiftOutputDir = getSwiftOutputPath(projectRoot);
       outputPath = getOutputPath(swiftOutputDir, name, 'swift');
     } else {
       const kotlinOutputDir = config.kotlin;
@@ -84,17 +85,35 @@ async function generateForStore(
   }
 }
 
-export type RunCodegenOptions = { platform?: Platform };
+export type RunCodegenOptions = {
+  platform?: Platform;
+  brownie?: BrownieConfig;
+  projectRoot?: string;
+};
 
 /**
  * Runs the codegen command with the given arguments.
  */
-export async function runCodegen({ platform }: RunCodegenOptions) {
+export async function runCodegen({
+  platform,
+  brownie,
+  projectRoot,
+}: RunCodegenOptions) {
   intro(
     `Running Brownie codegen for ${platform ? `platform ${platform}` : 'all platforms'}`
   );
 
-  const config = loadConfig();
+  const resolvedProjectRoot = projectRoot ?? findProjectRoot();
+  const { config, usedLegacyConfig } = resolveBrownieCodegenConfig({
+    brownie,
+    projectRoot: resolvedProjectRoot,
+  });
+
+  if (usedLegacyConfig) {
+    logger.warn(
+      'You are using legacy Brownie configuration. Please migrate to the new configuration format. See the documentation for more details: https://oss.callstack.com/react-native-brownfield/docs/api-reference/configuration#migrating-from-legacy-brownie-configuration'
+    );
+  }
 
   if (platform && !['swift', 'kotlin'].includes(platform)) {
     logger.error(`Invalid platform: ${platform}. Must be 'swift' or 'kotlin'`);
@@ -102,7 +121,7 @@ export async function runCodegen({ platform }: RunCodegenOptions) {
   }
 
   try {
-    const stores = discoverStores();
+    const stores = discoverStores(resolvedProjectRoot);
     const isMultipleStores = stores.length > 1;
     const schemaList = stores
       .map((s) => path.basename(s.schemaPath))
@@ -122,7 +141,13 @@ export async function runCodegen({ platform }: RunCodegenOptions) {
         platforms = ['swift', 'kotlin'];
       }
 
-      await generateForStore(store, config, platforms, isMultipleStores);
+      await generateForStore(
+        store,
+        config,
+        platforms,
+        isMultipleStores,
+        resolvedProjectRoot
+      );
     }
   } catch (error) {
     if (error instanceof NoBrownieStoresError) {

package/src/brownie/config.ts

@@ -1,21 +1,32 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { createRequire } from 'node:module';
+import { findProjectRoot } from '../brownfield/utils/paths.js';
+import { loadBrownfieldConfig } from '../config.js';
+import type { BrownieConfig } from '../types.js';
 
-export interface BrownieConfig {
-  kotlin?: string;
-  kotlinPackageName?: string;
-}
+const LEGACY_AND_NEW_BROWNIE_CONFIG_ERROR =
+  'Cannot use both legacy and new Brownie configuration formats simultaneously. Please migrate to the new configuration format and remove legacy configuration files: https://oss.callstack.com/react-native-brownfield/docs/api-reference/configuration#migrating-from-legacy-brownie-configuration';
 
 interface PackageJson {
   brownie?: BrownieConfig;
 }
 
+function loadPackageJson(projectRoot: string = findProjectRoot()): PackageJson {
+  const packageJsonPath = path.resolve(projectRoot, 'package.json');
+
+  if (!fs.existsSync(packageJsonPath)) {
+    throw new Error('package.json not found');
+  }
+
+  return JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8')) as PackageJson;
+}
+
 /**
  * Checks if @callstack/brownie package is installed.
  */
 export function isBrownieInstalled(
-  projectRoot: string = process.cwd()
+  projectRoot: string = findProjectRoot()
 ): boolean {
   const require = createRequire(path.join(projectRoot, 'package.json'));
   try {
@@ -30,7 +41,7 @@ export function isBrownieInstalled(
  * Resolves the path to the @callstack/brownie package.
  */
 export function getBrowniePackagePath(
-  projectRoot: string = process.cwd()
+  projectRoot: string = findProjectRoot()
 ): string {
   const require = createRequire(path.join(projectRoot, 'package.json'));
   try {
@@ -48,24 +59,70 @@ export function getBrowniePackagePath(
  * Returns the output path for generated Swift files.
  */
 export function getSwiftOutputPath(
-  projectRoot: string = process.cwd()
+  projectRoot: string = findProjectRoot()
 ): string {
   const browniePath = getBrowniePackagePath(projectRoot);
   return path.join(browniePath, 'ios', 'Generated');
 }
 
+/**
+ * Returns whether package.json contains legacy brownie config.
+ */
+export function hasLegacyConfig(
+  projectRoot: string = findProjectRoot()
+): boolean {
+  const packageJson = loadPackageJson(projectRoot);
+
+  return Object.prototype.hasOwnProperty.call(packageJson, 'brownie');
+}
+
 /**
  * Loads brownie config from package.json in the current working directory.
  */
-export function loadConfig(): BrownieConfig {
-  const packageJsonPath = path.resolve(process.cwd(), 'package.json');
+export function loadConfig(
+  projectRoot: string = findProjectRoot()
+): BrownieConfig {
+  const packageJson = loadPackageJson(projectRoot);
 
-  if (!fs.existsSync(packageJsonPath)) {
-    throw new Error('package.json not found');
+  return packageJson.brownie ?? {};
+}
+
+export type ResolveBrownieCodegenConfigOptions = {
+  brownie?: BrownieConfig;
+  projectRoot?: string;
+};
+
+export type ResolvedBrownieCodegenConfig = {
+  config: BrownieConfig;
+  usedLegacyConfig: boolean;
+};
+
+/**
+ * Resolves Brownie codegen settings from explicit options, brownfield config,
+ * or legacy package.json `brownie` config.
+ */
+export function resolveBrownieCodegenConfig({
+  brownie,
+  projectRoot = findProjectRoot(),
+}: ResolveBrownieCodegenConfigOptions = {}): ResolvedBrownieCodegenConfig {
+  const legacyConfig = hasLegacyConfig(projectRoot)
+    ? loadConfig(projectRoot)
+    : undefined;
+  const brownfieldBrownie = loadBrownfieldConfig(projectRoot).brownie;
+
+  if (legacyConfig !== undefined && (brownie ?? brownfieldBrownie)) {
+    throw new Error(LEGACY_AND_NEW_BROWNIE_CONFIG_ERROR);
   }
 
-  const packageJson: PackageJson = JSON.parse(
-    fs.readFileSync(packageJsonPath, 'utf-8')
-  );
-  return packageJson.brownie ?? {};
+  if (legacyConfig !== undefined) {
+    return {
+      config: legacyConfig,
+      usedLegacyConfig: true,
+    };
+  }
+
+  return {
+    config: brownie ?? brownfieldBrownie ?? {},
+    usedLegacyConfig: false,
+  };
 }

package/src/brownie/helpers/runBrownieCodegenIfApplicable.ts

@@ -1,7 +1,7 @@
 import { runCodegen } from '../commands/codegen.js';
 import { isBrownieInstalled } from '../config.js';
 
-import type { Platform } from '../types.js';
+import type { Platform } from '../../types.js';
 
 export async function runBrownieCodegenIfApplicable(
   projectRoot: string,
@@ -9,7 +9,7 @@ export async function runBrownieCodegenIfApplicable(
 ) {
   const hasBrownie = isBrownieInstalled(projectRoot);
   if (hasBrownie) {
-    await runCodegen({ platform });
+    await runCodegen({ platform, projectRoot });
   }
 
   return { hasBrownie };

package/src/brownie/index.ts

@@ -2,7 +2,6 @@ import { styleText } from 'node:util';
 
 import * as Commands from './commands/index.js';
 
-export type * from './types.js';
 export * from './store-discovery.js';
 
 export const groupName = `${styleText(['bold', 'blueBright'], '@callstack/brownie')}${styleText('whiteBright', ' - Shared state management CLI for React Native Brownfield')}`;

package/src/config.ts

@@ -0,0 +1,119 @@
+import fs from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+
+import Ajv from 'ajv';
+
+import type { BrownfieldConfig } from './types.js';
+import { findProjectRoot } from './brownfield/utils/paths.js';
+
+import BrownfieldSchema from '../schema.json' with { type: 'json' };
+import { logger } from '@rock-js/tools';
+
+const CONFIG_BASE_NAME = 'brownfield';
+const JS_CONFIG_FILE_NAME = `${CONFIG_BASE_NAME}.config.js`;
+const JSON_CONFIG_FILE_NAME = `${CONFIG_BASE_NAME}.config.json`;
+
+const SEPARATOR = '\n● ';
+
+const ajv = new Ajv({ allErrors: true });
+const validateBrownfieldConfig = ajv.compile(BrownfieldSchema);
+
+export function validateBrownfieldCLIConfig(config: unknown): void {
+  if (!validateBrownfieldConfig(config)) {
+    logger.warn(
+      `Brownfield configuration has some issues: ${SEPARATOR}${ajv.errorsText(validateBrownfieldConfig.errors, { separator: SEPARATOR, dataVar: 'config' })}.`
+    );
+  }
+}
+
+export function loadBrownfieldConfig(
+  projectRoot: string = findProjectRoot()
+): BrownfieldConfig {
+  const require = createRequire(path.join(projectRoot, 'package.json'));
+
+  const jsConfigFilePath = path.join(projectRoot, JS_CONFIG_FILE_NAME);
+  const jsonConfigFilePath = path.join(projectRoot, JSON_CONFIG_FILE_NAME);
+  const packageJsonPath = path.join(projectRoot, 'package.json');
+  const packageJson = require(packageJsonPath) as Record<string, unknown>;
+
+  if (
+    [
+      fs.existsSync(jsConfigFilePath),
+      fs.existsSync(jsonConfigFilePath),
+      packageJson[CONFIG_BASE_NAME],
+    ].filter(Boolean).length > 1
+  ) {
+    throw new Error('Project has multiple Brownfield configuration files');
+  }
+
+  if (fs.existsSync(jsConfigFilePath)) {
+    return require(jsConfigFilePath) as BrownfieldConfig;
+  }
+
+  if (fs.existsSync(jsonConfigFilePath)) {
+    return require(jsonConfigFilePath) as BrownfieldConfig;
+  }
+
+  return packageJson[CONFIG_BASE_NAME] || {};
+}
+
+type BrownfieldPlatform = 'android' | 'ios';
+type ConfigurableOptions = Record<string, unknown>;
+
+function getSharedConfig(config: BrownfieldConfig): ConfigurableOptions {
+  return config.verbose === undefined ? {} : { verbose: config.verbose };
+}
+
+function formatConfigValue(value: unknown): string {
+  return typeof value === 'string' ? value : JSON.stringify(value);
+}
+
+function areConfigValuesEqual(configValue: unknown, optionValue: unknown) {
+  return JSON.stringify(configValue) === JSON.stringify(optionValue);
+}
+
+export function mergeBrownfieldConfigWithOptions<T extends object>(
+  options: T,
+  platform: BrownfieldPlatform
+): T {
+  const reactNativeBrownfieldConfig = loadBrownfieldConfig();
+
+  validateBrownfieldCLIConfig(reactNativeBrownfieldConfig);
+
+  const platformConfig: ConfigurableOptions = {
+    ...getSharedConfig(reactNativeBrownfieldConfig),
+    ...reactNativeBrownfieldConfig[platform],
+  };
+
+  const cliOptions = Object.fromEntries(
+    Object.entries(options).filter(([, value]) => value !== undefined)
+  );
+
+  for (const [key, value] of Object.entries(cliOptions)) {
+    const configValue = platformConfig[key];
+
+    if (
+      configValue !== undefined &&
+      !areConfigValuesEqual(configValue, value)
+    ) {
+      logger.warn(
+        'CLI option "%s" is overriding the react-native-brownfield config value: %s -> %s.',
+        key,
+        formatConfigValue(configValue),
+        formatConfigValue(value)
+      );
+    }
+  }
+
+  const mergedOptions = {
+    ...platformConfig,
+    ...cliOptions,
+  } as T & { verbose?: unknown };
+
+  if (typeof mergedOptions.verbose === 'boolean') {
+    logger.setVerbose(mergedOptions.verbose);
+  }
+
+  return mergedOptions;
+}

package/src/navigation/commands/codegen.ts

@@ -42,9 +42,7 @@ export const navigationCodegenCommand = new Command('navigation:codegen')
         const specPath = typeof args[0] === 'string' ? args[0] : undefined;
         const options =
           args.find(
-            (
-              arg
-            ): arg is RunNavigationCodegenCommandOptions =>
+            (arg): arg is RunNavigationCodegenCommandOptions =>
               typeof arg === 'object' && arg !== null && 'dryRun' in arg
           ) ?? {};
 

package/src/navigation/generators/ts.ts

@@ -56,14 +56,72 @@ export default TurboModuleRegistry.getEnforcing<Spec>(
 `;
 }
 
+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 collectTypesUsedByMethods(methods: MethodSignature[]): Set<string> {
+  const used = new Set<string>();
+
+  for (const method of methods) {
+    const typeTexts = [
+      method.returnType,
+      ...method.params.map((param) => param.type),
+    ];
+
+    for (const typeText of typeTexts) {
+      const matches = typeText.match(/\b[A-Za-z_]\w*\b/g);
+      if (!matches) {
+        continue;
+      }
+
+      for (const name of matches) {
+        if (!SKIP_TYPE_TOKENS.has(name)) {
+          used.add(name);
+        }
+      }
+    }
+  }
+
+  return used;
+}
+
 function buildTypeImportLine(
+  methods: MethodSignature[],
   referencedTypeDeclarations: TypeDeclaration[]
 ): string {
   if (referencedTypeDeclarations.length === 0) {
     return '';
   }
 
-  const names = referencedTypeDeclarations.map((entry) => entry.name).join(', ');
+  const usedTypes = collectTypesUsedByMethods(methods);
+  const names = referencedTypeDeclarations
+    .map((entry) => entry.name)
+    .filter((name) => usedTypes.has(name))
+    .join(', ');
+
+  if (names.length === 0) {
+    return '';
+  }
+
   return `import type { ${names} } from './NativeBrownfieldNavigation';\n`;
 }
 
@@ -71,7 +129,7 @@ export function generateIndexTs(
   methods: MethodSignature[],
   referencedTypeDeclarations: TypeDeclaration[] = []
 ): string {
-  const typeImportLine = buildTypeImportLine(referencedTypeDeclarations);
+  const typeImportLine = buildTypeImportLine(methods, referencedTypeDeclarations);
   const functionImplementations = methods
     .map((method) => {
       const params = method.params
@@ -155,7 +213,7 @@ export function generateIndexDts(
   methods: MethodSignature[],
   referencedTypeDeclarations: TypeDeclaration[] = []
 ): string {
-  const typeImportLine = buildTypeImportLine(referencedTypeDeclarations);
+  const typeImportLine = buildTypeImportLine(methods, referencedTypeDeclarations);
   const methodSignatures = methods
     .map((method) => {
       const params = method.params