Core Application

/**
 * Create a new compodoc application instance
 * @param options - Configuration options for the application
 */
class Application {
  constructor(options?: Object);
  
  // Public properties
  files: Array<string>;
  updatedFiles: Array<string>;
  watchChangedFiles: Array<string>;
  isWatching: boolean;
  
  // Core generation methods
  protected generate(): Promise<{}>;
  protected testCoverage(): void;
  
  // File management
  setFiles(files: Array<string>): void;
  setUpdatedFiles(files: Array<string>): void;
  clearUpdatedFiles(): void;
  
  // File checking utilities
  hasWatchedFilesTSFiles(): boolean;
  hasWatchedFilesRootMarkdownFiles(): boolean;
  
  // Development server
  runWebServer(folder: string): void;
  runWatch(): void;
  
  // Content preparation methods
  prepareModules(someModules?: any): Promise<any>;
  preparePipes(somePipes?: any): Promise<any>;
  prepareClasses(someClasses?: any): Promise<any>;
  prepareInterfaces(someInterfaces?: any): Promise<any>;
  prepareMiscellaneous(someMisc?: any): Promise<any>;
  prepareControllers(someControllers?: any): Promise<any>;
  prepareEntities(someEntities?: any): Promise<any>;
  prepareComponents(someComponents?: any): Promise<any>;
  prepareDirectives(someDirectives?: any): Promise<any>;
  prepareInjectables(someInjectables?: any): Promise<void>;
  prepareInterceptors(someInterceptors?: any): Promise<void>;
  prepareGuards(someGuards?: any): Promise<void>;
  prepareRoutes(): Promise<void>;
  prepareCoverage(): Promise<any>;
  prepareUnitTestCoverage(): Promise<any>;
  
  // Page processing
  processPages(): void;
  processAdditionalPages(): void;
  processAssetsFolder(): void;
  processResources(): void;
  processGraphs(): void;
}

import { Application } from "@compodoc/compodoc";

// Basic usage
const app = new Application({
  tsconfig: "./tsconfig.json",
  output: "./documentation"
});

app.generate().then(() => {
  console.log("Documentation generated successfully");
});

// Advanced configuration
const advancedApp = new Application({
  tsconfig: "./tsconfig.json",
  output: "./docs",
  name: "My Angular App Documentation",
  theme: "material",
  serve: true,
  port: 4000,
  watch: true,
  disableGraph: false,
  disableCoverage: false,
  coverageTest: 80,
  exportFormat: "html",
  language: "en-US"
});

advancedApp.generate();

/**
 * CLI application class extending Application for command-line usage
 */
class CliApplication extends Application {
  protected start(): any;
  
  // Inherits all methods and properties from Application
}

import { CliApplication } from "@compodoc/compodoc";

// Programmatic CLI usage
const cliApp = new CliApplication();
cliApp.start(); // Processes command-line arguments and runs generation

/**
 * Store files for initial processing
 * @param files - Array of file paths to process
 */
setFiles(files: Array<string>): void;

/**
 * Store files for watch processing
 * @param files - Array of updated file paths
 */
setUpdatedFiles(files: Array<string>): void;

/**
 * Clear files for watch processing
 */
clearUpdatedFiles(): void;

/**
 * Check presence of TypeScript files in updatedFiles list
 * @returns True if TypeScript files are present
 */
hasWatchedFilesTSFiles(): boolean;

/**
 * Check presence of root markdown files in updatedFiles list
 * @returns True if root markdown files are present
 */
hasWatchedFilesRootMarkdownFiles(): boolean;

/**
 * Start development web server
 * @param folder - Folder to serve documentation from
 */
runWebServer(folder: string): void;

/**
 * Start file watching for development mode
 */
runWatch(): void;

/**
 * Prepare modules for documentation generation
 * @param someModules - Optional specific modules to prepare
 * @returns Promise resolving when preparation is complete
 */
prepareModules(someModules?: any): Promise<any>;

/**
 * Prepare components for documentation generation
 * @param someComponents - Optional specific components to prepare
 * @returns Promise resolving when preparation is complete
 */
prepareComponents(someComponents?: any): Promise<any>;

/**
 * Prepare directives for documentation generation
 * @param someDirectives - Optional specific directives to prepare
 * @returns Promise resolving when preparation is complete
 */
prepareDirectives(someDirectives?: any): Promise<any>;

/**
 * Prepare injectables for documentation generation
 * @param someInjectables - Optional specific injectables to prepare
 * @returns Promise resolving when preparation is complete
 */
prepareInjectables(someInjectables?: any): Promise<void>;

/**
 * Prepare guards for documentation generation
 * @param someGuards - Optional specific guards to prepare
 * @returns Promise resolving when preparation is complete
 */
prepareGuards(someGuards?: any): Promise<void>;

/**
 * Prepare pipes for documentation generation
 * @param somePipes - Optional specific pipes to prepare
 * @returns Promise resolving when preparation is complete
 */
preparePipes(somePipes?: any): Promise<any>;

/**
 * Prepare classes for documentation generation
 * @param someClasses - Optional specific classes to prepare
 * @returns Promise resolving when preparation is complete
 */
prepareClasses(someClasses?: any): Promise<any>;

/**
 * Prepare interfaces for documentation generation
 * @param someInterfaces - Optional specific interfaces to prepare
 * @returns Promise resolving when preparation is complete
 */
prepareInterfaces(someInterfaces?: any): Promise<any>;

/**
 * Process routes for documentation generation
 * @returns Promise resolving when routes are processed
 */
prepareRoutes(): Promise<void>;

/**
 * Process documentation coverage report
 * @returns Promise resolving when coverage is processed
 */
prepareCoverage(): Promise<any>;

/**
 * Process unit test coverage report
 * @returns Promise resolving when unit test coverage is processed
 */
prepareUnitTestCoverage(): Promise<any>;