Module Discovery

/**
 * Find modules in specified search paths and app root
 * @param params - Find modules parameters
 * @returns Promise resolving to search results
 */
function findModulesAsync(params: FindModulesParams): Promise<SearchResults>;

interface FindModulesParams {
  appRoot: string;
  autolinkingOptions: AutolinkingOptions & { platform: SupportedPlatform };
}

import { findModulesAsync, createAutolinkingOptionsLoader } from "expo-modules-autolinking";

// Find modules for iOS platform
const autolinkingOptionsLoader = createAutolinkingOptionsLoader({ platform: "ios" });
const appRoot = await autolinkingOptionsLoader.getAppRoot();
const autolinkingOptions = await autolinkingOptionsLoader.getPlatformOptions("ios");

const searchResults = await findModulesAsync({
  appRoot,
  autolinkingOptions
});

console.log("Found modules:", Object.keys(searchResults));

/**
 * Resolve found modules into platform-specific descriptors
 * @param searchResults - Results from findModulesAsync
 * @param options - Autolinking options
 * @returns Promise resolving to module descriptors
 */
function resolveModulesAsync(
  searchResults: SearchResults,
  options: AutolinkingOptions
): Promise<ModuleDescriptor[]>;

/**
 * Resolve extra build dependencies for platform
 * @param params - Resolution parameters
 * @returns Promise resolving to extra dependencies
 */
function resolveExtraBuildDependenciesAsync(params: ResolveParams): Promise<ExtraDependencies>;

interface ResolveParams {
  commandRoot: string;
  platform: SupportedPlatform;
}

import { resolveModulesAsync, resolveExtraBuildDependenciesAsync } from "expo-modules-autolinking";

// Resolve modules from search results
const modules = await resolveModulesAsync(searchResults, autolinkingOptions);

// Get extra build dependencies
const extraDependencies = await resolveExtraBuildDependenciesAsync({
  commandRoot: autolinkingOptionsLoader.getCommandRoot(),
  platform: "ios"
});

console.log("Resolved modules:", modules.map(m => m.packageName));
console.log("Extra dependencies:", extraDependencies);

/**
 * Generate package list for Android platform
 * @param modules - Array of resolved module descriptors
 * @param options - Package list generation options
 */
function generatePackageListAsync(
  modules: ModuleDescriptor[],
  options: PackageListOptions
): Promise<void>;

/**
 * Generate modules provider for Apple platforms
 * @param modules - Array of resolved module descriptors
 * @param options - Modules provider generation options
 */
function generateModulesProviderAsync(
  modules: ModuleDescriptor[],
  options: ModulesProviderOptions
): Promise<void>;

interface PackageListOptions {
  target: string;
  namespace?: string;
  empty?: boolean;
}

interface ModulesProviderOptions {
  target: string;
  entitlement?: string;
  packages?: string[];
}

import { generatePackageListAsync, generateModulesProviderAsync } from "expo-modules-autolinking";

// Generate Android package list
await generatePackageListAsync(modules, {
  target: "./android/app/src/main/java/MainApplication.java",
  namespace: "com.myapp"
});

// Generate iOS modules provider
await generateModulesProviderAsync(modules, {
  target: "./ios/MyApp/ExpoModulesProvider.swift",
  entitlement: "./ios/MyApp/MyApp.entitlements"
});

/**
 * Get autolinking configuration for current options
 * @param params - Configuration parameters
 * @returns Configuration object or null
 */
function getConfiguration(params: {
  autolinkingOptions: AutolinkingOptions;
}): any;

import { getConfiguration } from "expo-modules-autolinking";

// Get platform configuration
const config = getConfiguration({ autolinkingOptions });

if (config) {
  console.log("Platform configuration:", config);
}

/**
 * Query autolinking modules from a project for specific platform
 * @param projectRoot - Root directory of the project
 * @param options - Query configuration options including platform
 * @returns Promise resolving to array of resolved module descriptors
 * @deprecated Use newer autolinking options loader instead
 */
function queryAutolinkingModulesFromProjectAsync(
  projectRoot: string,
  options: QueryAutolinkingModulesFromProjectParams
): Promise<ModuleDescriptor[]>;

interface QueryAutolinkingModulesFromProjectParams extends Partial<AutolinkingCommonArguments> {
  platform: SupportedPlatform;
  [extra: string]: unknown;
}

/**
 * Merge command arguments with autolinking options
 * @param argumentsOptions - Command line argument options
 * @returns Promise resolving to merged autolinking options
 * @deprecated Use createAutolinkingOptionsLoader instead
 */
function mergeLinkingOptionsAsync<Options extends Partial<AutolinkingCommonArguments>>(
  argumentsOptions: Options
): Promise<Options & AutolinkingOptions>;

/**
 * Find project root directory by searching for package.json
 * @param cwd - Current working directory to search from
 * @returns Path to directory containing package.json
 * @deprecated Use newer project discovery mechanisms
 */
function findProjectRootSync(cwd?: string): string;

/**
 * Resolve and validate search paths for module discovery
 * @param searchPaths - Array of search path strings or null
 * @param cwd - Current working directory for relative path resolution
 * @returns Promise resolving to array of resolved search paths
 * @deprecated Use newer search path resolution mechanisms
 */
function resolveSearchPathsAsync(
  searchPaths: string[] | null,
  cwd: string
): Promise<string[]>;

type SearchResults = {
  [moduleName: string]: PackageRevision;
};

interface PackageRevision {
  name: string;
  path: string;
  version: string;
  config?: ExpoModuleConfig;
  duplicates?: PackageRevision[];
}

interface ExtraDependencies {
  [platform: string]: any[];
}

import { 
  createAutolinkingOptionsLoader,
  findModulesAsync,
  resolveModulesAsync,
  resolveExtraBuildDependenciesAsync,
  generateModulesProviderAsync
} from "expo-modules-autolinking";

async function completeAutolinkingWorkflow(platform: SupportedPlatform) {
  // 1. Create options loader
  const optionsLoader = createAutolinkingOptionsLoader({ platform });
  
  // 2. Get configuration
  const appRoot = await optionsLoader.getAppRoot();
  const autolinkingOptions = await optionsLoader.getPlatformOptions(platform);
  
  // 3. Find modules
  const searchResults = await findModulesAsync({
    appRoot,
    autolinkingOptions
  });
  
  // 4. Resolve modules
  const modules = await resolveModulesAsync(searchResults, autolinkingOptions);
  
  // 5. Get extra dependencies
  const extraDeps = await resolveExtraBuildDependenciesAsync({
    commandRoot: optionsLoader.getCommandRoot(),
    platform
  });
  
  // 6. Generate source files (example for iOS)
  if (platform === "ios") {
    await generateModulesProviderAsync(modules, {
      target: "./ios/MyApp/ExpoModulesProvider.swift"
    });
  }
  
  return { modules, extraDeps };
}