Configuration System

/**
 * Get complete configuration schema including extensions
 * @param extensions - Whether to include extension schemas (default: true)
 * @returns Complete configuration schema object
 */
function getSchema(extensions?: boolean): ConfigSchema;

/**
 * Finalize schema by merging extension schemas
 * @param extensions - Whether to include extension schemas (default: true)
 * @returns Finalized configuration schema
 */
function finalizeSchema(extensions?: boolean): ConfigSchema;

/**
 * Get default values for the configuration schema
 * @param extensions - Whether to include extension defaults (default: true)
 * @returns Object containing default configuration values
 */
function getDefaultsForSchema(extensions?: boolean): Record<string, any>;

import { getSchema, finalizeSchema, getDefaultsForSchema } from "appium";

// Get complete schema with extensions
const schema = getSchema();

// Get schema without extensions
const coreSchema = getSchema(false);

// Finalize schema for validation
const finalSchema = finalizeSchema();

// Get default configuration values
const defaults = getDefaultsForSchema();
console.log("Default port:", defaults.port);

/**
 * Validate configuration arguments against schema
 * @param args - Configuration arguments to validate
 * @param schema - Schema to validate against (optional, uses default if not provided)
 * @throws Error if validation fails
 */
function validate(args: ParsedArgs, schema?: ConfigSchema): void;

import { validate, getSchema } from "appium";

// Validate configuration
try {
  validate({
    port: 4723,
    address: "127.0.0.1",
    logLevel: "info"
  });
  console.log("Configuration is valid");
} catch (error) {
  console.error("Validation failed:", error.message);
}

// Validate with custom schema
const customSchema = getSchema(false);
validate(config, customSchema);

/**
 * Read and parse Appium configuration file
 * @param configFile - Path to configuration file (optional)
 * @returns Promise resolving to configuration result
 */
function readConfigFile(configFile?: string): Promise<ConfigResult>;

import { readConfigFile } from "appium";

// Read default configuration file
const configResult = await readConfigFile();

if (configResult.errors.length > 0) {
  console.error("Configuration errors:", configResult.errors);
} else {
  console.log("Loaded config from:", configResult.filepath);
  console.log("Server config:", configResult.config?.server);
}

// Read specific configuration file
const customConfig = await readConfigFile("./custom-appium.conf.js");

/**
 * Get server command argument specifications
 * @returns Array of server argument specifications
 */
function getServerArgs(): ArgSpec[];

/**
 * Get extension command argument specifications
 * @param extType - Extension type ("driver" or "plugin")
 * @returns Array of extension argument specifications
 */
function getExtensionArgs(extType: "driver" | "plugin"): ArgSpec[];

import { getServerArgs, getExtensionArgs } from "appium/lib/cli/args";

// Get server arguments
const serverArgs = getServerArgs();
console.log("Server arguments:", serverArgs.map(arg => arg.name));

// Get driver arguments
const driverArgs = getExtensionArgs("driver");
console.log("Driver commands:", driverArgs.map(arg => arg.name));

// Get plugin arguments  
const pluginArgs = getExtensionArgs("plugin");
console.log("Plugin commands:", pluginArgs.map(arg => arg.name));

interface ConfigSchema {
  type: "object";
  properties: Record<string, SchemaProperty>;
  additionalProperties?: boolean;
  required?: string[];
}

interface SchemaProperty {
  type: string | string[];
  description?: string;
  default?: any;
  enum?: any[];
  minimum?: number;
  maximum?: number;
  items?: SchemaProperty;
  properties?: Record<string, SchemaProperty>;
}

interface ConfigResult {
  /** Path to the configuration file that was read */
  filepath?: string;
  /** Parsed configuration object */
  config?: {
    server?: Record<string, any>;
    [key: string]: any;
  };
  /** Array of configuration errors */
  errors: string[];
  /** Human-readable error description */
  reason?: string;
}

interface ArgSpec {
  /** Argument name */
  name: string;
  /** Argument description */
  description: string;
  /** Argument type */
  type: "string" | "number" | "boolean" | "array" | "object";
  /** Default value */
  defaultValue?: any;
  /** Required argument */
  required?: boolean;
  /** CLI flag name */
  flag?: string;
  /** CLI alias */
  alias?: string;
  /** Possible values for enum types */
  choices?: any[];
  /** Validation function */
  validate?: (value: any) => boolean;
}

interface ParsedArgs {
  /** Server port number */
  port?: number;
  /** Server bind address */
  address?: string;
  /** Server base path */
  basePath?: string;
  /** Allow CORS requests */
  allowCors?: boolean;
  /** Logging level */
  logLevel?: "error" | "warn" | "info" | "http" | "verbose" | "debug" | "silly";
  /** Configuration file path */
  configFile?: string;
  /** Temporary directory path */
  tmpDir?: string;
  /** Default capabilities */
  defaultCapabilities?: Record<string, any>;
  /** Request timeout in seconds */
  requestTimeout?: number;
  /** Keep-alive timeout in seconds */
  keepAliveTimeout?: number;
  /** Specific drivers to use */
  useDrivers?: string[];
  /** Specific plugins to use */
  usePlugins?: string[];
  /** Disable permissions check */
  noPermsCheck?: boolean;
  /** Show configuration and exit */
  showConfig?: boolean;
  /** Show build information and exit */
  showBuildInfo?: boolean;
  /** Show debug information and exit */
  showDebugInfo?: boolean;
  /** Enable long stack traces */
  longStacktrace?: boolean;
  /** Log filtering rules */
  logFilters?: LogFilterRule[];
  /** Selenium Grid node configuration */
  nodeconfig?: string;
  /** CLI subcommand */
  subcommand?: string;
  [key: string]: any;
}

interface LogFilterRule {
  pattern: string;
  replacement?: string;
  flags?: string;
}