Core Management

/**
 * Returns the command-line application entrypoint for autorest-core
 * Bootstraps core if necessary. If initialize() was called, returns that version.
 * @param logger - Logger implementation  
 * @param requestedVersion - npm package reference (default: "latest-installed")
 * @param minimumVersion - semver minimum version string
 * @returns Promise resolving to entry point path or undefined if unavailable
 */
function getApplicationEntrypoint(
  logger: IAutorestLogger,
  requestedVersion?: string,
  minimumVersion?: string
): Promise<string | undefined>;

import { getApplicationEntrypoint } from "autorest";

// Get CLI entry point with default version
const entryPoint = await getApplicationEntrypoint(logger);
if (entryPoint) {
  console.log(`AutoRest CLI available at: ${entryPoint}`);
}

// Get specific version entry point
const specificEntry = await getApplicationEntrypoint(logger, "3.7.0");

// Get entry point with minimum version requirement
const compatibleEntry = await getApplicationEntrypoint(
  logger, 
  "latest", 
  "3.5.0"
);

/**
 * Initializes the AutoRest-core module, bootstrapping from npm if required
 * @param logger - Logger implementation for output
 * @param requestedVersion - npm package reference for version (default: "latest-installed")
 * @param minimumVersion - semver string for minimum acceptable version
 * @returns Promise that resolves when initialization is complete
 */
function initialize(
  logger: IAutorestLogger,
  requestedVersion?: string,
  minimumVersion?: string
): Promise<void>;

import { initialize } from "autorest";

// Initialize with latest installed version
await initialize(logger);

// Initialize with specific version
await initialize(logger, "3.7.0");

// Initialize with version range and minimum requirement
await initialize(logger, "^3.0.0", "3.5.0");

// Initialize with npm tag
await initialize(logger, "beta");

/**
 * AutoRest class promise - resolved after core is loaded
 * Use create() function instead of accessing this directly
 */
const AutoRest: Promise<IAutoRest>;

/**
 * Main AutoRest interface - actual implementation loaded dynamically from core
 * Use create() function to get instances of this interface
 */
interface AutoRest {
  /**
   * Add configuration to the AutoRest instance
   * @param config - Configuration object or settings
   */
  AddConfiguration(config: any): Promise<void>;
  
  /**
   * Process the configured specifications and generate code
   * @returns Promise resolving to generation results
   */
  Process(): Promise<GenerationResults>;
  
  // Additional methods available from dynamically loaded core
  // Exact interface depends on loaded @autorest/core version
}

import { AutoRest, create } from "autorest";

// Wait for AutoRest class to be available (not recommended - use create())
const AutoRestClass = await AutoRest;
const instance = new AutoRestClass(fileSystem, configUri);

// Recommended approach using create()
const autorest = await create(logger, fileSystem, configUri);
await autorest.AddConfiguration({ "csharp": true });
const results = await autorest.Process();

try {
  await initialize(logger, "3.7.0");
  const entryPoint = await getApplicationEntrypoint(logger);
  console.log("Core initialized successfully:", entryPoint);
} catch (error) {
  console.error("Core initialization failed:", error);
  // Handle initialization errors appropriately
}