ccjk 12.0.6 → 12.0.7

package/dist/index.d.ts

@@ -2707,5 +2707,2589 @@ declare function assertDefined<T>(value: T | null | undefined, message?: string)
  */
 declare function assert(condition: boolean, message?: string): asserts condition;
 
-export { AiderTool, BaseCodeTool, BaseError, ClaudeCodeTool, ClineTool, CodexTool, ConfigManager, ConfigValidator, ConfigurationError, ContinueTool, CursorTool, InternalError, Logger, Mutex, NotFoundError, Semaphore, TimeoutError, ToolFactory, ToolRegistry, UnauthorizedError, ValidationError, index$6 as array, assert, assertDefined, index$5 as async, batchProcessFiles, camelCase, capitalize, chunk, index$4 as command, commandExists$1 as commandExists, config, copyFile, countLines, createConfigManager, createLogger, createTool, createValidator, debounce, deepClone, deepMerge, deleteDir, deleteFile, difference, ensureDir, index$3 as error, executeCommand, executeCommandStream, exists, extractDisplayName, extractString, flatten, flatten$1 as flattenArray, formatError, index$2 as fs, generateCompactWelcome, generateRecommendations, generateWelcome, get, getArchitecture, getCacheDir, getCapabilitiesByType, getCapability, getCommandPath, getCommandVersion, getConfigDir, getDataDir, getErrorMessage, getFileInfo, getFileSize, getHomeDir, getPlatform, getPlatformInfo, getRegistry, getTempDir, has, i18nHelpers, intersection, isArray, isBoolean, isDefined, isDirectory, isEmail, isFile, isLargeFile, isLinux, isMacOS, isNumber, isObject, isString, isURL, isUnix, isWindows, kebabCase, listDirs, listFiles, logger, logger$2 as loggerUtils, moveFile, normalizeRecommendation, normalizeRecommendations, index$1 as object, omit, parallelLimit, partition, pascalCase, pick, platform, processLargeFile, processLineByLine, readFile, readJSON, retry, scanCapabilities, sequence, set, shuffle, sleep, slugify, snakeCase, streamJSON, streamWriteJSON, index as string, template, throttle, timeout, truncate, tryCatch, tryCatchAsync, unflatten, union, unique, validation, validators, waitFor, wrapError, writeFile, writeJSON };
-export type { Capability, CapabilityScanResult, CapabilityStatus, CapabilityType, ChunkProcessorOptions, ExecutionResult, FileInfo, IChatTool, ICodeGenTool, ICodeTool, IFileEditTool, InstallStatus, MultilingualString, StreamProcessorOptions, ToolCapabilities, ToolConfig, ToolMetadata, WelcomeOptions };
+/**
+ * Cloud Client DTO (Data Transfer Objects)
+ *
+ * Strict type definitions and converters for API responses
+ * Eliminates `any` types in core cloud flows
+ *
+ * @module cloud-client/dto
+ */
+
+/**
+ * MCP Server Configuration
+ */
+interface McpServerConfig {
+    type?: 'stdio' | 'http' | 'websocket';
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    npmPackage?: string;
+    installCommand?: string;
+}
+/**
+ * Skill Configuration
+ */
+interface SkillConfig {
+    enabled?: boolean;
+    priority?: number;
+    triggers?: string[];
+    parameters?: Record<string, string | number | boolean>;
+}
+/**
+ * Agent Configuration
+ */
+interface AgentConfig {
+    persona?: string;
+    capabilities?: string[];
+    skills?: string[];
+    mcpServers?: string[];
+    temperature?: number;
+    maxTokens?: number;
+}
+/**
+ * Hook Configuration
+ */
+interface HookConfig {
+    command?: string;
+    args?: string[];
+    when?: 'pre' | 'post';
+    enabled?: boolean;
+}
+/**
+ * Workflow Configuration
+ */
+interface WorkflowConfig {
+    steps?: string[];
+    triggers?: string[];
+    conditions?: Record<string, string | boolean>;
+}
+/**
+ * Union type for all config types
+ */
+type RecommendationConfig = McpServerConfig | SkillConfig | AgentConfig | HookConfig | WorkflowConfig;
+/**
+ * Allowed template parameter default values
+ */
+type TemplateParameterValue = string | number | boolean | string[] | number[] | Record<string, string | number | boolean> | null;
+/**
+ * Template download telemetry data
+ */
+interface TemplateDownloadData {
+    templateId: string;
+    templateType: string;
+    timestamp: number;
+}
+/**
+ * Recommendation shown telemetry data
+ */
+interface RecommendationShownData {
+    recommendationId: string;
+    category: string;
+    timestamp: number;
+}
+/**
+ * Recommendation accepted telemetry data
+ */
+interface RecommendationAcceptedData {
+    recommendationId: string;
+    category: string;
+    timestamp: number;
+}
+/**
+ * Analysis completed telemetry data
+ */
+interface AnalysisCompletedData {
+    projectType?: string;
+    frameworks?: string[];
+    recommendationCount: number;
+    timestamp: number;
+}
+/**
+ * Error occurred telemetry data
+ */
+interface ErrorOccurredData {
+    errorType: string;
+    errorMessage?: string;
+    context?: string;
+    timestamp: number;
+}
+/**
+ * Batch telemetry data
+ */
+interface BatchTelemetryData {
+    events: Array<{
+        type: MetricType;
+        data?: TelemetryEventData;
+        timestamp: string;
+    }>;
+    batchSize: number;
+    userId: string;
+}
+/**
+ * Union type for all telemetry data
+ */
+type TelemetryEventData = TemplateDownloadData | RecommendationShownData | RecommendationAcceptedData | AnalysisCompletedData | ErrorOccurredData | BatchTelemetryData;
+/**
+ * Raw recommendation from cloud API
+ */
+interface RawRecommendation {
+    id: string;
+    name: string | Record<string, string>;
+    description: string | Record<string, string>;
+    category: 'skill' | 'mcp' | 'agent' | 'hook';
+    relevanceScore: number;
+    installCommand?: string;
+    config?: unknown;
+    tags?: string[];
+    dependencies?: string[];
+}
+/**
+ * Raw template from cloud API
+ */
+interface RawTemplate {
+    id: string;
+    type: 'workflow' | 'output-style' | 'prompt' | 'agent';
+    name: string | Record<string, string>;
+    description: string | Record<string, string>;
+    content: string;
+    version: string;
+    author?: string;
+    tags?: string[];
+    parameters?: Array<{
+        name: string;
+        type: 'string' | 'number' | 'boolean' | 'object' | 'array';
+        required: boolean;
+        default?: unknown;
+        description?: string | Record<string, string>;
+    }>;
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * Raw project analysis response from cloud API
+ */
+interface RawProjectAnalysisResponse {
+    requestId: string;
+    recommendations: RawRecommendation[];
+    projectType?: string;
+    frameworks?: string[];
+}
+/**
+ * Raw batch template response from cloud API
+ */
+interface RawBatchTemplateResponse {
+    requestId: string;
+    templates: Record<string, RawTemplate>;
+    notFound: string[];
+}
+/**
+ * Validate and convert config object
+ */
+declare function convertConfig(config: unknown): RecommendationConfig | undefined;
+/**
+ * Convert template parameter default value
+ */
+declare function convertParameterDefault(value: unknown): TemplateParameterValue;
+/**
+ * Convert raw recommendation to typed recommendation
+ */
+declare function convertRecommendation(raw: RawRecommendation, preferredLang?: 'en' | 'zh-CN'): Recommendation;
+/**
+ * Convert raw template parameter to typed parameter
+ */
+declare function convertTemplateParameter(raw: {
+    name: string;
+    type: 'string' | 'number' | 'boolean' | 'object' | 'array';
+    required: boolean;
+    default?: unknown;
+    description?: string | Record<string, string>;
+}): TemplateParameter;
+/**
+ * Convert raw template to typed template
+ */
+declare function convertTemplate(raw: RawTemplate, preferredLang?: 'en' | 'zh-CN'): TemplateResponse;
+/**
+ * Convert raw project analysis response to typed response
+ */
+declare function convertProjectAnalysisResponse(raw: RawProjectAnalysisResponse, preferredLang?: 'en' | 'zh-CN'): ProjectAnalysisResponse;
+/**
+ * Convert raw batch template response to typed response
+ */
+declare function convertBatchTemplateResponse(raw: RawBatchTemplateResponse, preferredLang?: 'en' | 'zh-CN'): BatchTemplateResponse$1;
+/**
+ * Validate project analysis request
+ */
+declare function validateProjectAnalysisRequest(request: ProjectAnalysisRequest): {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Validate batch template request
+ */
+declare function validateBatchTemplateRequest(request: BatchTemplateRequest): {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Validate usage report
+ */
+declare function validateUsageReport(report: UsageReport): {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Check if value is a valid recommendation config
+ */
+declare function isRecommendationConfig(value: unknown): value is RecommendationConfig;
+/**
+ * Check if value is a valid telemetry event data
+ */
+declare function isTelemetryEventData(value: unknown): value is TelemetryEventData;
+/**
+ * Check if value is a valid template parameter value
+ */
+declare function isTemplateParameterValue(value: unknown): value is TemplateParameterValue;
+
+/**
+ * Cloud Client API Types
+ *
+ * Type definitions for the CCJK Cloud API v1.0.0
+ * @module cloud-client/types
+ */
+/**
+ * Project analysis request payload
+ */
+interface ProjectAnalysisRequest {
+    /** Project root directory path */
+    projectRoot: string;
+    /** Package.json dependencies */
+    dependencies?: Record<string, string>;
+    /** Dev dependencies */
+    devDependencies?: Record<string, string>;
+    /** Git repository URL */
+    gitRemote?: string;
+    /** Project language (zh-CN, en, ja, ko) */
+    language?: string;
+    /** CCJK version */
+    ccjkVersion?: string;
+}
+/**
+ * Recommended tool or workflow
+ */
+interface Recommendation {
+    /** Unique identifier */
+    id: string;
+    /** Display name (multilingual) */
+    name: Record<string, string>;
+    /** Description (multilingual) */
+    description: Record<string, string>;
+    /** Category: skill, mcp, agent, hook */
+    category: 'skill' | 'mcp' | 'agent' | 'hook';
+    /** Relevance score (0-1) */
+    relevanceScore: number;
+    /** Install command */
+    installCommand?: string;
+    /** Configuration JSON - use RecommendationConfig from dto.ts for strict typing */
+    config?: RecommendationConfig;
+    /** Tags for filtering */
+    tags?: string[];
+    /** Dependencies required */
+    dependencies?: string[];
+}
+/**
+ * Project analysis response
+ */
+interface ProjectAnalysisResponse {
+    /** Unique request ID for tracking */
+    requestId: string;
+    /** Array of personalized recommendations */
+    recommendations: Recommendation[];
+    /** Project type detection result */
+    projectType?: string;
+    /** Framework detection results */
+    frameworks?: string[];
+}
+/**
+ * Template type
+ */
+type TemplateType$1 = 'workflow' | 'output-style' | 'prompt' | 'agent';
+/**
+ * Template response
+ */
+interface TemplateResponse {
+    /** Unique template identifier */
+    id: string;
+    /** Template type */
+    type: TemplateType$1;
+    /** Template name (multilingual) */
+    name: Record<string, string>;
+    /** Template description (multilingual) */
+    description: Record<string, string>;
+    /** Template content */
+    content: string;
+    /** Version */
+    version: string;
+    /** Author */
+    author?: string;
+    /** Tags */
+    tags?: string[];
+    /** Required parameters */
+    parameters?: TemplateParameter[];
+    /** ISO 8601 creation timestamp */
+    createdAt: string;
+    /** ISO 8601 update timestamp */
+    updatedAt: string;
+}
+/**
+ * Template parameter definition
+ */
+interface TemplateParameter {
+    /** Parameter name */
+    name: string;
+    /** Parameter type */
+    type: 'string' | 'number' | 'boolean' | 'object' | 'array';
+    /** Required flag */
+    required: boolean;
+    /** Default value - use TemplateParameterValue from dto.ts for strict typing */
+    default?: TemplateParameterValue;
+    /** Description (multilingual) */
+    description?: Record<string, string>;
+}
+/**
+ * Batch template request
+ */
+interface BatchTemplateRequest {
+    /** Template IDs to fetch */
+    ids: string[];
+    /** Language for translations */
+    language?: string;
+}
+/**
+ * Batch template response
+ */
+interface BatchTemplateResponse$1 {
+    /** Request ID for tracking */
+    requestId: string;
+    /** Map of template ID to template content */
+    templates: Record<string, TemplateResponse>;
+    /** IDs that were not found */
+    notFound: string[];
+}
+/**
+ * Usage metric type
+ */
+type MetricType = 'template_download' | 'recommendation_shown' | 'recommendation_accepted' | 'analysis_completed' | 'error_occurred';
+/**
+ * Usage report payload
+ */
+interface UsageReport {
+    /** Unique report ID */
+    reportId: string;
+    /** Metric type */
+    metricType: MetricType;
+    /** ISO 8601 timestamp */
+    timestamp: string;
+    /** CCJK version */
+    ccjkVersion: string;
+    /** Node.js version */
+    nodeVersion: string;
+    /** Operating system */
+    platform: string;
+    /** Project language if applicable */
+    language?: string;
+    /** Additional context data - use TelemetryEventData from dto.ts for strict typing */
+    data?: TelemetryEventData;
+}
+/**
+ * Usage report response
+ */
+interface UsageReportResponse {
+    /** Success indicator */
+    success: boolean;
+    /** Request ID */
+    requestId: string;
+    /** Message from server */
+    message?: string;
+}
+/**
+ * Health check response
+ */
+interface HealthCheckResponse {
+    /** Service health status */
+    status: 'healthy' | 'degraded' | 'unhealthy';
+    /** API version */
+    version: string;
+    /** Current timestamp */
+    timestamp: string;
+    /** Optional service messages */
+    message?: string;
+}
+/**
+ * Cloud client error types
+ * @deprecated Use CloudErrorCode from './errors' instead
+ */
+type CloudClientErrorType = 'NETWORK_ERROR' | 'TIMEOUT_ERROR' | 'API_ERROR' | 'VALIDATION_ERROR' | 'AUTH_ERROR' | 'RATE_LIMIT_ERROR' | 'SERVER_ERROR' | 'UNKNOWN_ERROR';
+/**
+ * Cloud client error class
+ * @deprecated Use CloudError from './errors' instead
+ */
+declare class CloudClientError extends Error {
+    /** Error type */
+    readonly type: CloudClientErrorType;
+    /** HTTP status code if applicable */
+    readonly statusCode?: number;
+    /** Original error */
+    readonly originalError?: unknown;
+    constructor(type: CloudClientErrorType, message: string, statusCode?: number, originalError?: unknown);
+    /**
+     * Create error from HTTP response
+     */
+    static fromResponse(statusCode: number, message: string): CloudClientError;
+    /**
+     * Create network error
+     */
+    static network(error: unknown): CloudClientError;
+    /**
+     * Create timeout error
+     */
+    static timeout(timeout: number): CloudClientError;
+    /**
+     * Create validation error
+     */
+    static validation(message: string): CloudClientError;
+}
+/**
+ * Cloud client configuration
+ */
+interface CloudClientConfig {
+    /** API base URL */
+    baseURL: string;
+    /** Request timeout in milliseconds */
+    timeout?: number;
+    /** CCJK version header */
+    version?: string;
+    /** Enable caching */
+    enableCache?: boolean;
+    /** Cache directory path */
+    cacheDir?: string;
+    /** Enable retry logic */
+    enableRetry?: boolean;
+    /** Maximum retry attempts */
+    maxRetries?: number;
+    /** Enable telemetry reporting */
+    enableTelemetry?: boolean;
+    /** API key if required */
+    apiKey?: string;
+    /** Language for API responses */
+    language?: string;
+}
+/**
+ * Cache entry metadata
+ */
+interface CacheEntry<T> {
+    /** Cached data */
+    data: T;
+    /** Expiration timestamp */
+    expiresAt: number;
+    /** Cache key */
+    key: string;
+}
+/**
+ * Retry configuration
+ */
+interface RetryConfig {
+    /** Maximum retry attempts */
+    maxAttempts: number;
+    /** Initial delay in milliseconds */
+    initialDelay: number;
+    /** Backoff multiplier */
+    multiplier: number;
+    /** Maximum delay in milliseconds */
+    maxDelay: number;
+    /** HTTP status codes to retry */
+    retryableStatusCodes: number[];
+}
+/**
+ * Telemetry configuration
+ */
+interface TelemetryConfig {
+    /** Enable telemetry reporting */
+    enabled: boolean;
+    /** Batch size before sending */
+    batchSize: number;
+    /** Maximum time to wait before sending (ms) */
+    flushInterval: number;
+    /** Anonymous user ID */
+    userId?: string;
+}
+
+/**
+ * Cloud Client Implementation
+ *
+ * Main HTTP client for CCJK Cloud API
+ * @module cloud-client/client
+ */
+
+/**
+ * Cloud Client Class
+ *
+ * Provides methods to interact with the CCJK Cloud API
+ */
+declare class CloudClient {
+    private fetch;
+    private config;
+    constructor(config: CloudClientConfig);
+    /**
+     * Calculate retry delay with exponential backoff
+     */
+    private calculateRetryDelay;
+    /**
+     * Handle fetch errors and convert to CloudClientError
+     */
+    private handleError;
+    /**
+     * Analyze project and get recommendations
+     *
+     * POST /api/v1/analysis/projects
+     *
+     * @param request - Project analysis request
+     * @returns Project analysis response with recommendations
+     */
+    analyzeProject(request: ProjectAnalysisRequest): Promise<ProjectAnalysisResponse>;
+    /**
+     * Get a single template by ID
+     *
+     * GET /api/v1/templates/:id
+     *
+     * @param id - Template identifier
+     * @param language - Language for translations (optional)
+     * @returns Template response
+     */
+    getTemplate(id: string, language?: string): Promise<TemplateResponse>;
+    /**
+     * Get multiple templates in batch
+     *
+     * POST /api/v1/templates/batch
+     *
+     * @param request - Batch template request
+     * @returns Batch template response
+     */
+    getBatchTemplates(request: BatchTemplateRequest): Promise<BatchTemplateResponse$1>;
+    /**
+     * Report usage metrics (non-blocking with short timeout)
+     *
+     * POST /api/v1/telemetry/installation
+     *
+     * @param report - Usage report payload
+     * @returns Usage report response
+     */
+    reportUsage(report: UsageReport): Promise<UsageReportResponse>;
+    /**
+     * Check API health status
+     *
+     * GET /api/v1/health
+     *
+     * @returns Health check response
+     */
+    healthCheck(): Promise<HealthCheckResponse>;
+    /**
+     * Update client configuration
+     *
+     * @param config - Partial configuration to update
+     */
+    updateConfig(config: Partial<CloudClientConfig>): void;
+    /**
+     * Get current configuration
+     */
+    getConfig(): CloudClientConfig;
+}
+/**
+ * Create a default cloud client instance
+ */
+declare function createCloudClient(config?: Partial<CloudClientConfig>): CloudClient;
+
+/**
+ * Simple in-memory cache with filesystem persistence
+ */
+declare class CloudCache {
+    private memoryCache;
+    private cacheDir;
+    private enabled;
+    constructor(config: CloudClientConfig);
+    /**
+     * Ensure cache directory exists
+     */
+    private ensureCacheDir;
+    /**
+     * Load cache from disk
+     */
+    private loadCacheFromDisk;
+    /**
+     * Save cache to disk
+     */
+    private saveCacheToDisk;
+    /**
+     * Generate cache key from parameters
+     */
+    generateKey(prefix: string, params: Record<string, unknown> | object): string;
+    /**
+     * Get cached value
+     *
+     * @param key - Cache key
+     * @returns Cached value or undefined if not found/expired
+     */
+    get<T>(key: string): T | undefined;
+    /**
+     * Set cached value with TTL
+     *
+     * @param key - Cache key
+     * @param value - Value to cache
+     * @param ttlSeconds - Time to live in seconds
+     */
+    set<T>(key: string, value: T, ttlSeconds: number): void;
+    /**
+     * Delete cache entry
+     *
+     * @param key - Cache key
+     */
+    delete(key: string): void;
+    /**
+     * Clear all cache entries
+     */
+    clear(): void;
+    /**
+     * Clean expired entries
+     */
+    cleanExpired(): void;
+    /**
+     * Get cache statistics
+     */
+    getStats(): {
+        size: number;
+        keys: string[];
+    };
+}
+/**
+ * Cached Cloud Client
+ *
+ * Wraps CloudClient with caching layer
+ */
+declare class CachedCloudClient {
+    private client;
+    private cache;
+    constructor(client: CloudClient, cache: CloudCache);
+    /**
+     * Analyze project with caching (7-day TTL)
+     */
+    analyzeProject(request: ProjectAnalysisRequest): Promise<ProjectAnalysisResponse>;
+    /**
+     * Get template with caching (30-day TTL)
+     */
+    getTemplate(id: string, language?: string): Promise<TemplateResponse>;
+    /**
+     * Get batch templates with caching (30-day TTL)
+     */
+    getBatchTemplates(request: BatchTemplateRequest): Promise<BatchTemplateResponse$1>;
+    /**
+     * Report usage (no caching)
+     */
+    reportUsage(report: UsageReport): Promise<UsageReportResponse>;
+    /**
+     * Health check with caching (5-minute TTL)
+     */
+    healthCheck(): Promise<HealthCheckResponse>;
+    /**
+     * Clear cache
+     */
+    clearCache(): void;
+    /**
+     * Clean expired cache entries
+     */
+    cleanCache(): void;
+    /**
+     * Get cache statistics
+     */
+    getCacheStats(): {
+        size: number;
+        keys: string[];
+    };
+    /**
+     * Get underlying client
+     */
+    getClient(): CloudClient;
+}
+
+/**
+ * Type definitions for the project analysis engine
+ */
+interface ProjectAnalysis {
+    /** Project root directory */
+    rootPath: string;
+    /** Detected project type (primary language/framework) */
+    projectType: string;
+    /** All detected languages with confidence scores */
+    languages: LanguageDetection[];
+    /** Detected frameworks and libraries */
+    frameworks: FrameworkDetectionResult[];
+    /** Package manager used */
+    packageManager?: PackageManager;
+    /** Build system detected */
+    buildSystem?: BuildSystem;
+    /** Relative paths to important configuration files */
+    configFiles: string[];
+    /** Relative paths to important directories */
+    importantDirs: string[];
+    /** Dependency analysis results */
+    dependencies?: DependencyAnalysis;
+    /** Analysis metadata */
+    metadata: AnalysisMetadata;
+}
+interface LanguageDetection {
+    /** Language name (typescript, python, go, rust, etc.) */
+    language: string;
+    /** Confidence score (0-1) */
+    confidence: number;
+    /** Estimated number of files */
+    fileCount: number;
+    /** Primary indication reasons */
+    indicators: string[];
+}
+interface FrameworkDetectionResult {
+    /** Framework name */
+    name: string;
+    /** Framework category (frontend, backend, mobile, desktop, etc.) */
+    category: string;
+    /** Detected version if available */
+    version?: string;
+    /** Confidence score (0-1) */
+    confidence: number;
+    /** Detection evidence */
+    evidence: string[];
+}
+type PackageManager = 'npm' | 'yarn' | 'pnpm' | 'bun' | 'pip' | 'poetry' | 'pipenv' | 'conda' | 'go' | 'cargo' | 'mod' | 'gradle' | 'maven' | 'unknown';
+type BuildSystem = 'webpack' | 'vite' | 'rollup' | 'esbuild' | 'tsc' | 'babel' | 'swc' | 'next' | 'nuxt' | 'svelte' | 'make' | 'cmake' | 'bazel' | 'unknown';
+interface DependencyAnalysis {
+    /** Direct dependencies */
+    direct: DependencyNode[];
+    /** All transitive dependencies */
+    all: DependencyNode[];
+    /** Dependency graph (key = dependency name, value = array of dependents) */
+    graph: Map<string, DependencyNode[]>;
+    /** Installation plan with optimal order */
+    installationPlan: InstallationPlan;
+    /** Detected conflicts */
+    conflicts: DependencyConflict[];
+    /** Circular dependencies detected */
+    circularDeps: string[][];
+}
+interface DependencyNode {
+    /** Package/dependency name */
+    name: string;
+    /** Version requirement */
+    version: string;
+    /** Type of dependency */
+    type: DependencyType;
+    /** Whether this is a dev dependency */
+    isDev: boolean;
+    /** Whether this is a peer dependency */
+    isPeer: boolean;
+    /** Whether this is an optional dependency */
+    isOptional: boolean;
+    /** Dependencies of this dependency */
+    dependencies?: DependencyNode[];
+}
+type DependencyType = 'runtime' | 'dev' | 'peer' | 'optional' | 'bundled';
+interface InstallationPlan {
+    /** Ordered list of dependencies to install */
+    order: DependencyNode[];
+    /** Total number of dependencies */
+    total: number;
+    /** Number that can be installed in parallel */
+    parallelizable: number;
+    /** Installation commands for each package manager */
+    commands: InstallationCommands;
+}
+interface InstallationCommands {
+    /** Command to install all dependencies */
+    installAll: string;
+    /** Command to install a specific package */
+    installPackage: (name: string, version?: string) => string;
+    /** Command to install dev dependencies */
+    installDev: string;
+    /** Command to add a new dependency */
+    add: (name: string, isDev?: boolean) => string;
+}
+interface DependencyConflict {
+    /** Package name with conflict */
+    package: string;
+    /** Conflicting version requirements */
+    versions: string[];
+    /** Packages requiring these versions */
+    requiredBy: string[];
+    /** Severity level */
+    severity: 'error' | 'warning' | 'info';
+}
+interface AnalysisMetadata {
+    /** Analysis timestamp */
+    timestamp: Date;
+    /** Analysis duration in milliseconds */
+    duration: number;
+    /** Number of files scanned */
+    filesScanned: number;
+    /** Analysis confidence (0-1) */
+    confidence: number;
+    /** Analysis version */
+    version: string;
+}
+
+type HookType = 'pre-commit' | 'post-commit' | 'pre-push' | 'post-push' | 'pre-test' | 'post-test' | 'pre-build' | 'post-build' | 'pre-install' | 'post-install' | 'pre-start' | 'post-start' | 'custom';
+type HookCategory = 'pre-commit' | 'post-test' | 'lifecycle' | 'custom';
+interface HookTrigger {
+    matcher: string;
+    condition?: string;
+    parameters?: Record<string, any>;
+}
+interface HookAction {
+    command: string;
+    args?: string[];
+    workingDirectory?: string;
+    environment?: Record<string, string>;
+    timeout?: number;
+}
+interface HookMetadata {
+    version?: string;
+    author?: string;
+    tags?: string[];
+    projectTypes?: string[];
+    created?: string;
+    updated?: string;
+    ccjkVersion?: string;
+}
+interface HookTemplate {
+    name: string;
+    description: string;
+    type: HookType;
+    category: HookCategory;
+    projectTypes: string[];
+    trigger: HookTrigger;
+    action: HookAction;
+    enabled: boolean;
+    priority: number;
+    metadata?: HookMetadata;
+}
+
+/**
+ * Get hook recommendations from cloud service
+ */
+declare function getCloudRecommendedHooks(projectInfo: ProjectAnalysis, options?: {
+    includeCommunity?: boolean;
+    includePremium?: boolean;
+    limit?: number;
+}): Promise<HookTemplate[]>;
+/**
+ * Submit hook usage analytics
+ */
+declare function submitHookAnalytics(hookName: string, projectInfo: ProjectAnalysis, result: 'installed' | 'skipped' | 'error'): Promise<void>;
+/**
+ * Get popular hooks from community
+ */
+declare function getCommunityHooks(limit?: number, category?: string): Promise<HookTemplate[]>;
+
+/**
+ * Agent Template Loader
+ *
+ * Loads and manages agent templates from templates/agents directory
+ */
+/**
+ * Agent recommendation structure (simplified from templates)
+ */
+interface AgentRecommendation {
+    name: string;
+    description: string;
+    skills: string[];
+    mcpServers: string[];
+    persona?: string;
+    capabilities: string[];
+    confidence: number;
+    reason: string;
+}
+
+/**
+ * Cloud Recommendations
+ *
+ * Provides agent recommendations from cloud service
+ */
+
+/**
+ * Get agent recommendations from cloud
+ */
+declare function getCloudRecommendations(analysis: ProjectAnalysis): Promise<AgentRecommendation[]>;
+/**
+ * Get skill recommendations from cloud
+ */
+declare function getCloudSkillRecommendations(analysis: ProjectAnalysis): Promise<any[]>;
+/**
+ * Get MCP recommendations from cloud
+ */
+declare function getCloudMcpRecommendations(analysis: ProjectAnalysis): Promise<any[]>;
+
+/**
+ * Retry wrapper for async functions
+ *
+ * @param fn - Function to retry
+ * @param config - Retry configuration
+ * @returns Promise that resolves with function result
+ */
+declare function withRetry<T>(fn: () => Promise<T>, config?: Partial<RetryConfig>): Promise<T>;
+/**
+ * Retryable Cloud Client
+ *
+ * Wraps CloudClient with retry logic
+ */
+declare class RetryableCloudClient {
+    private client;
+    private retryConfig;
+    constructor(client: CloudClient, retryConfig?: Partial<RetryConfig>);
+    /**
+     * Analyze project with retry
+     */
+    analyzeProject: (request: ProjectAnalysisRequest) => Promise<ProjectAnalysisResponse>;
+    /**
+     * Get template with retry
+     */
+    getTemplate: (id: string, language?: string) => Promise<TemplateResponse>;
+    /**
+     * Get batch templates with retry
+     */
+    getBatchTemplates: (request: BatchTemplateRequest) => Promise<BatchTemplateResponse$1>;
+    /**
+     * Report usage (no retry)
+     */
+    reportUsage: (report: UsageReport) => Promise<UsageReportResponse>;
+    /**
+     * Health check (no retry)
+     */
+    healthCheck: () => Promise<HealthCheckResponse>;
+    /**
+     * Get underlying client
+     */
+    getClient(): CloudClient;
+}
+/**
+ * Retry utilities
+ */
+declare const retryUtils: {
+    /**
+     * Retry a function with exponential backoff
+     */
+    withRetry: typeof withRetry;
+    /**
+     * Calculate retry delay
+     */
+    calculateDelay(attempt: number, initialDelay?: number, multiplier?: number, maxDelay?: number): number;
+    /**
+     * Check if error is retryable
+     */
+    isRetryable(error: unknown): boolean;
+};
+
+/**
+ * CCJK Cloud Templates Client
+ *
+ * Client for v8 Templates API - unified template management for Agent, MCP, Skill, Hook
+ * @module cloud-client/templates-client
+ */
+type TemplateType = 'skill' | 'mcp' | 'agent' | 'hook';
+interface Template {
+    id: string;
+    type: TemplateType;
+    name_en: string;
+    name_zh_cn?: string;
+    description_en?: string;
+    description_zh_cn?: string;
+    category: string;
+    tags: string[];
+    template_content?: string;
+    content?: string;
+    author?: string;
+    version: string;
+    repository_url?: string;
+    npm_package?: string;
+    install_command?: string;
+    documentation_url?: string;
+    config_schema?: Record<string, unknown>;
+    requirements?: string[];
+    compatibility?: {
+        platforms?: string[];
+        frameworks?: string[];
+        languages?: string[];
+        [key: string]: unknown;
+    };
+    usage_examples?: Array<{
+        title: string;
+        description: string;
+        code: string;
+    }>;
+    is_official: boolean;
+    is_featured: boolean;
+    is_verified: boolean;
+    download_count: number;
+    rating_average: number;
+    rating_count: number;
+    last_updated?: string;
+    created_at: string;
+    updated_at: string;
+}
+interface TemplateSearchParams {
+    query?: string;
+    type?: TemplateType;
+    category?: string;
+    tags?: string[];
+    is_official?: boolean;
+    is_featured?: boolean;
+    is_verified?: boolean;
+    sortBy?: 'name_en' | 'download_count' | 'rating_average' | 'updated_at';
+    order?: 'asc' | 'desc';
+    limit?: number;
+    offset?: number;
+}
+interface TemplateListResponse {
+    items: Template[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+interface BatchTemplateResponse {
+    requestId: string;
+    templates: Record<string, Template>;
+    notFound: string[];
+    stats?: {
+        totalTemplates: number;
+        cacheHits: number;
+        cacheMisses: number;
+        cacheSize: number;
+    };
+}
+interface TemplatesClientConfig {
+    baseURL?: string;
+    timeout?: number;
+    language?: 'en' | 'zh-CN';
+}
+/**
+ * CCJK Cloud Templates Client
+ *
+ * Provides methods to interact with the v8 Templates API
+ */
+declare class TemplatesClient {
+    private fetch;
+    private baseURL;
+    private language;
+    private logger;
+    constructor(config?: TemplatesClientConfig);
+    /**
+     * Get a single template by ID
+     */
+    getTemplate(templateId: string): Promise<Template | null>;
+    /**
+     * Batch get templates by IDs
+     */
+    getTemplates(ids: string[], language?: 'en' | 'zh-CN'): Promise<BatchTemplateResponse>;
+    /**
+     * Search templates
+     */
+    searchTemplates(query: string, params?: Omit<TemplateSearchParams, 'query'>): Promise<TemplateListResponse>;
+    /**
+     * List templates with filters
+     */
+    listTemplates(params?: TemplateSearchParams): Promise<TemplateListResponse>;
+    /**
+     * Get templates by type
+     */
+    getTemplatesByType(type: TemplateType, options?: {
+        category?: string;
+        limit?: number;
+        is_official?: boolean;
+    }): Promise<Template[]>;
+    /**
+     * Get specialist agents
+     */
+    getSpecialistAgents(category?: string): Promise<Template[]>;
+    /**
+     * Get official MCP servers
+     */
+    getOfficialMcpServers(): Promise<Template[]>;
+    /**
+     * Get skills by category
+     */
+    getSkills(category?: string): Promise<Template[]>;
+    /**
+     * Get hooks by category
+     */
+    getHooks(category?: string): Promise<Template[]>;
+    /**
+     * Get featured templates
+     */
+    getFeaturedTemplates(limit?: number): Promise<Template[]>;
+    /**
+     * Get popular templates
+     */
+    getPopularTemplates(limit?: number): Promise<Template[]>;
+    /**
+     * Get all categories
+     */
+    getCategories(): Promise<string[]>;
+    /**
+     * Track template download
+     */
+    trackDownload(templateId: string): Promise<boolean>;
+    /**
+     * Build search params string
+     */
+    private buildSearchParams;
+    /**
+     * Extract localized name from template
+     */
+    getLocalizedName(template: Template, lang?: 'en' | 'zh-CN'): string;
+    /**
+     * Extract localized description from template
+     */
+    getLocalizedDescription(template: Template, lang?: 'en' | 'zh-CN'): string;
+}
+/**
+ * Get or create the singleton TemplatesClient instance
+ */
+declare function getTemplatesClient(config?: TemplatesClientConfig): TemplatesClient;
+/**
+ * Create a new TemplatesClient instance
+ */
+declare function createTemplatesClient(config?: TemplatesClientConfig): TemplatesClient;
+
+/**
+ * Standardized Cloud Client Error Handling
+ *
+ * Provides unified error codes, localized messages, and utility functions
+ * for all cloud client operations.
+ *
+ * @module cloud-client/errors
+ */
+/**
+ * Standard cloud error codes
+ */
+declare enum CloudErrorCode {
+    /** Authentication failed (401) */
+    AUTH_ERROR = "AUTH_ERROR",
+    /** Rate limit exceeded (429) */
+    RATE_LIMIT = "RATE_LIMIT",
+    /** Response schema mismatch or validation error */
+    SCHEMA_MISMATCH = "SCHEMA_MISMATCH",
+    /** Network connection error */
+    NETWORK_ERROR = "NETWORK_ERROR",
+    /** Request timeout */
+    TIMEOUT = "TIMEOUT",
+    /** Server error (5xx) */
+    SERVER_ERROR = "SERVER_ERROR",
+    /** Resource not found (404) */
+    NOT_FOUND = "NOT_FOUND",
+    /** Generic API error (4xx) */
+    API_ERROR = "API_ERROR",
+    /** Validation error (client-side) */
+    VALIDATION_ERROR = "VALIDATION_ERROR",
+    /** Unknown error */
+    UNKNOWN_ERROR = "UNKNOWN_ERROR"
+}
+/**
+ * Cloud error metadata
+ */
+interface CloudErrorMetadata {
+    /** HTTP status code if applicable */
+    statusCode?: number;
+    /** Original error object */
+    originalError?: unknown;
+    /** Additional context data */
+    context?: Record<string, any>;
+    /** Retry attempt number */
+    retryAttempt?: number;
+    /** Request ID for tracking */
+    requestId?: string;
+}
+/**
+ * Standardized Cloud Error Class
+ *
+ * Extends Error with cloud-specific error codes and localized messages
+ */
+declare class CloudError extends Error {
+    /** Error code */
+    readonly code: CloudErrorCode;
+    /** HTTP status code if applicable */
+    readonly statusCode?: number;
+    /** Original error */
+    readonly originalError?: unknown;
+    /** Additional context */
+    readonly context?: Record<string, any>;
+    /** Retry attempt number */
+    readonly retryAttempt?: number;
+    /** Request ID */
+    readonly requestId?: string;
+    /** Whether this error is retryable */
+    readonly isRetryable: boolean;
+    constructor(code: CloudErrorCode, message: string, metadata?: CloudErrorMetadata);
+    /**
+     * Get localized error message
+     */
+    getLocalizedMessage(language?: string): string;
+    /**
+     * Get user-friendly error message with context
+     */
+    getUserMessage(language?: string): string;
+    /**
+     * Convert to JSON for logging
+     */
+    toJSON(): Record<string, any>;
+}
+/**
+ * Error factory functions
+ */
+declare const CloudErrorFactory: {
+    /**
+     * Create error from HTTP response
+     */
+    fromHttpStatus(statusCode: number, message: string, metadata?: Omit<CloudErrorMetadata, "statusCode">): CloudError;
+    /**
+     * Create authentication error
+     */
+    auth(message?: string, metadata?: CloudErrorMetadata): CloudError;
+    /**
+     * Create rate limit error
+     */
+    rateLimit(message?: string, metadata?: CloudErrorMetadata): CloudError;
+    /**
+     * Create schema mismatch error
+     */
+    schemaMismatch(message?: string, metadata?: CloudErrorMetadata): CloudError;
+    /**
+     * Create network error
+     */
+    network(error: unknown, metadata?: CloudErrorMetadata): CloudError;
+    /**
+     * Create timeout error
+     */
+    timeout(timeoutMs: number, metadata?: CloudErrorMetadata): CloudError;
+    /**
+     * Create server error
+     */
+    server(message?: string, metadata?: CloudErrorMetadata): CloudError;
+    /**
+     * Create not found error
+     */
+    notFound(resource?: string, metadata?: CloudErrorMetadata): CloudError;
+    /**
+     * Create validation error
+     */
+    validation(message: string, metadata?: CloudErrorMetadata): CloudError;
+    /**
+     * Create unknown error
+     */
+    unknown(error: unknown, metadata?: CloudErrorMetadata): CloudError;
+};
+/**
+ * Error handling utilities
+ */
+/**
+ * Check if error code is retryable
+ */
+declare function isRetryableErrorCode(code: CloudErrorCode): boolean;
+/**
+ * Check if error is retryable
+ */
+declare function isRetryableError(error: unknown): boolean;
+/**
+ * Check if error is authentication error
+ */
+declare function isAuthError(error: unknown): boolean;
+/**
+ * Check if error is rate limit error
+ */
+declare function isRateLimitError(error: unknown): boolean;
+/**
+ * Handle cloud error with logging and user-friendly message
+ */
+declare function handleCloudError(error: unknown, context?: string, language?: string): CloudError;
+/**
+ * Get retry delay for error (exponential backoff)
+ */
+declare function getRetryDelay(error: CloudError, attempt: number, config?: {
+    initialDelay?: number;
+    multiplier?: number;
+    maxDelay?: number;
+}): number;
+/**
+ * Format error for logging
+ */
+declare function formatErrorForLogging(error: unknown): Record<string, any>;
+
+/**
+ * Pagination information
+ */
+interface Pagination {
+    /** Current page number (1-indexed) */
+    page: number;
+    /** Number of items per page */
+    limit: number;
+    /** Total number of items */
+    total: number;
+    /** Total number of pages */
+    totalPages: number;
+    /** Whether there are more pages */
+    hasNext: boolean;
+}
+/**
+ * User quota information
+ */
+interface Quota {
+    /** Number of skills currently installed */
+    used: number;
+    /** Maximum number of skills allowed */
+    limit: number;
+    /** Remaining skill slots */
+    remaining: number;
+    /** User's subscription tier */
+    tier: 'free' | 'pro' | 'enterprise';
+}
+/**
+ * Skill category enumeration
+ */
+type SkillCategory = 'development' | 'productivity' | 'writing' | 'analysis' | 'automation' | 'integration' | 'utility' | 'other';
+/**
+ * Skill provider enumeration
+ */
+type SkillProvider = 'official' | 'community' | 'verified' | 'third-party';
+/**
+ * Skill status enumeration
+ */
+type SkillStatus = 'active' | 'deprecated' | 'beta' | 'archived';
+/**
+ * Supported AI agents
+ */
+type SupportedAgent = 'claude-code' | 'codex' | 'aider' | 'continue' | 'cline' | 'cursor';
+/**
+ * Skill metadata
+ */
+interface SkillMetadata {
+    /** Minimum required version */
+    minVersion?: string;
+    /** Maximum supported version */
+    maxVersion?: string;
+    /** Required dependencies */
+    dependencies?: string[];
+    /** Skill configuration schema */
+    configSchema?: Record<string, unknown>;
+    /** Additional custom metadata */
+    [key: string]: unknown;
+}
+/**
+ * Complete skill information
+ */
+interface Skill {
+    /** Unique skill identifier */
+    skillId: string;
+    /** Skill name (English) */
+    name: string;
+    /** URL-friendly slug */
+    slug: string;
+    /** Skill name (Chinese) */
+    nameZh: string;
+    /** Description (English) */
+    descriptionEn: string;
+    /** Description (Chinese) */
+    descriptionZh: string;
+    /** Source repository name */
+    repo: string;
+    /** Source repository URL */
+    repoUrl: string;
+    /** GitHub stars count */
+    stars: number;
+    /** Total cloud install count */
+    installCount: number;
+    /** Local install count (from CLI) */
+    localInstallCount: number;
+    /** Skill category */
+    category: SkillCategory;
+    /** Skill tags for filtering */
+    tags: string[];
+    /** Skill provider type */
+    provider: SkillProvider;
+    /** Whether this is an official Anthropic skill */
+    isOfficial: boolean;
+    /** Whether this skill is verified */
+    isVerified: boolean;
+    /** Whether this skill is currently trending */
+    isTrending: boolean;
+    /** Trending rank (null if not trending) */
+    trendingRank: number | null;
+    /** Trigger command (e.g., "/commit") */
+    trigger: string;
+    /** Alternative trigger aliases */
+    aliases: string[];
+    /** CLI installation command */
+    installCommand: string;
+    /** List of supported AI agents */
+    supportedAgents: SupportedAgent[];
+    /** Average rating (1-5) */
+    ratingAvg: number;
+    /** Total number of ratings */
+    ratingCount: number;
+    /** Number of times searched */
+    searchCount: number;
+    /** Current skill status */
+    status: SkillStatus;
+    /** Additional metadata */
+    metadata: SkillMetadata;
+    /** Creation timestamp (ISO 8601) */
+    createdAt: string;
+    /** Last update timestamp (ISO 8601) */
+    updatedAt: string;
+}
+/**
+ * User's installed skill with usage information
+ */
+interface UserSkill {
+    /** Skill identifier */
+    skillId: string;
+    /** Skill name */
+    name: string;
+    /** Installation timestamp (ISO 8601) */
+    installedAt: string;
+    /** Last usage timestamp (ISO 8601, null if never used) */
+    lastUsedAt: string | null;
+    /** Total usage count */
+    usageCount: number;
+    /** Whether the skill is enabled */
+    isEnabled: boolean;
+    /** User's custom configuration */
+    config: Record<string, unknown>;
+}
+/**
+ * Skill rating/review
+ */
+interface Rating {
+    /** Unique rating identifier */
+    id: string;
+    /** User ID who created the rating */
+    userId: string;
+    /** Display name of the user */
+    userName: string;
+    /** Skill being rated */
+    skillId: string;
+    /** Rating value (1-5) */
+    rating: number;
+    /** Optional review text */
+    review: string | null;
+    /** Number of users who found this helpful */
+    helpful: number;
+    /** Creation timestamp (ISO 8601) */
+    createdAt: string;
+    /** Last update timestamp (ISO 8601) */
+    updatedAt: string;
+}
+/**
+ * Rating summary statistics
+ */
+interface RatingSummary {
+    /** Average rating */
+    average: number;
+    /** Total number of ratings */
+    count: number;
+    /** Distribution by star count */
+    distribution: {
+        1: number;
+        2: number;
+        3: number;
+        4: number;
+        5: number;
+    };
+}
+/**
+ * Parameters for marketplace listing
+ */
+interface MarketplaceParams {
+    /** Page number (1-indexed, default: 1) */
+    page?: number;
+    /** Items per page (default: 20, max: 100) */
+    limit?: number;
+    /** Filter by category */
+    category?: SkillCategory;
+    /** Filter by provider */
+    provider?: SkillProvider;
+    /** Sort order */
+    sort?: 'popular' | 'newest' | 'rating' | 'trending' | 'name';
+    /** Filter official skills only */
+    isOfficial?: boolean;
+    /** Filter trending skills only */
+    isTrending?: boolean;
+}
+/**
+ * Parameters for skill search
+ */
+interface SearchParams {
+    /** Search query string */
+    q: string;
+    /** Filter by category */
+    category?: SkillCategory;
+    /** Filter by provider */
+    provider?: SkillProvider;
+    /** Maximum results (default: 20) */
+    limit?: number;
+    /** Offset for pagination (default: 0) */
+    offset?: number;
+}
+/**
+ * Parameters for search suggestions
+ */
+interface SuggestionsParams {
+    /** Partial search query */
+    q: string;
+    /** Maximum suggestions (default: 10) */
+    limit?: number;
+}
+/**
+ * Parameters for trending skills
+ */
+interface TrendingParams {
+    /** Maximum results (default: 10) */
+    limit?: number;
+}
+/**
+ * Parameters for skill recommendations
+ */
+interface RecommendationsParams {
+    /** User ID for personalization */
+    userId?: string;
+    /** Maximum recommendations (default: 10) */
+    limit?: number;
+    /** Exclude already installed skills */
+    excludeInstalled?: boolean;
+}
+/**
+ * Request to install a skill
+ */
+interface InstallSkillRequest {
+    /** Skill ID to install */
+    skillId: string;
+    /** User's subscription tier (for quota validation) */
+    userTier?: 'free' | 'pro' | 'enterprise';
+}
+/**
+ * Request to update a user's skill
+ */
+interface UpdateSkillRequest {
+    /** Enable or disable the skill */
+    isEnabled?: boolean;
+    /** Custom configuration */
+    config?: Record<string, unknown>;
+}
+/**
+ * Available filter options
+ */
+interface MarketplaceFilters {
+    /** Available categories */
+    categories: SkillCategory[];
+    /** Available providers */
+    providers: SkillProvider[];
+    /** Available sort options */
+    sortOptions: string[];
+}
+/**
+ * Response for marketplace listing
+ */
+interface MarketplaceResponse {
+    /** List of skills */
+    skills: Skill[];
+    /** Pagination information */
+    pagination: Pagination;
+    /** Available filter options */
+    filters: MarketplaceFilters;
+}
+/**
+ * Response for skill search
+ */
+interface SearchResponse {
+    /** Search results */
+    results: Skill[];
+    /** Total matching results */
+    total: number;
+    /** Original search query */
+    query: string;
+}
+/**
+ * Search suggestion item
+ */
+interface Suggestion {
+    /** Suggested text */
+    text: string;
+    /** Suggestion type */
+    type: 'skill' | 'category' | 'tag';
+    /** Related skill ID (if type is 'skill') */
+    skillId?: string;
+}
+/**
+ * Response for search suggestions
+ */
+interface SuggestionsResponse {
+    /** List of suggestions */
+    suggestions: Suggestion[];
+}
+/**
+ * Response for trending skills
+ */
+interface TrendingResponse {
+    /** List of trending skills */
+    trending: Skill[];
+}
+/**
+ * Recommendation basis information
+ */
+interface RecommendationBasis {
+    /** Basis type */
+    type: 'similar_users' | 'installed_skills' | 'popular' | 'category';
+    /** Related skill IDs or categories */
+    related: string[];
+}
+/**
+ * Response for skill recommendations
+ */
+interface RecommendationsResponse {
+    /** List of recommended skills */
+    recommendations: Skill[];
+    /** Total available recommendations */
+    total: number;
+    /** Basis for recommendations */
+    basedOn: RecommendationBasis[];
+}
+/**
+ * Response for user's installed skills
+ */
+interface UserSkillsResponse {
+    /** List of user's installed skills */
+    skills: UserSkill[];
+    /** Total installed skills count */
+    total: number;
+    /** User's quota information */
+    quota: Quota;
+}
+/**
+ * Response for skill installation
+ */
+interface InstallResponse {
+    /** Installed skill ID */
+    skillId: string;
+    /** Installation timestamp (ISO 8601) */
+    installedAt: string;
+    /** Updated quota information */
+    quota: Quota;
+}
+/**
+ * Response for skill uninstallation
+ */
+interface UninstallResponse {
+    /** Uninstalled skill ID */
+    skillId: string;
+    /** Uninstallation timestamp (ISO 8601) */
+    uninstalledAt: string;
+    /** Updated quota information */
+    quota: Quota;
+}
+/**
+ * Response for skill update
+ */
+interface UpdateResponse {
+    /** Updated skill ID */
+    skillId: string;
+    /** New enabled status */
+    isEnabled: boolean;
+    /** Updated configuration */
+    config: Record<string, unknown>;
+    /** Update timestamp (ISO 8601) */
+    updatedAt: string;
+}
+
+/**
+ * Ratings API Client
+ *
+ * Handles all rating-related API calls for the skills marketplace.
+ * Provides functionality for fetching and creating skill ratings.
+ *
+ * @module ratings-api
+ */
+
+/** Sort options for ratings */
+type RatingSortOption = 'newest' | 'oldest' | 'highest' | 'lowest' | 'helpful';
+/**
+ * Parameters for fetching skill ratings
+ */
+interface GetSkillRatingsParams {
+    /** Page number (1-indexed) */
+    page?: number;
+    /** Number of items per page */
+    limit?: number;
+    /** Sort order for ratings */
+    sort?: RatingSortOption;
+}
+/**
+ * Response structure for getSkillRatings
+ */
+interface GetSkillRatingsResponse {
+    /** List of ratings */
+    ratings: Rating[];
+    /** Summary statistics for the skill's ratings */
+    summary: RatingSummary;
+    /** Pagination information */
+    pagination: Pagination;
+}
+/**
+ * Data required to create a new rating
+ */
+interface CreateRatingData {
+    /** ID of the user creating the rating */
+    userId: string;
+    /** Rating value (1-5 stars) */
+    rating: number;
+    /** Optional review text */
+    review?: string;
+}
+/**
+ * Response structure for createRating
+ */
+interface CreateRatingResponse {
+    /** Unique identifier for the rating */
+    id: number;
+    /** ID of the skill being rated */
+    skillId: string;
+    /** ID of the user who created the rating */
+    userId: string;
+    /** Rating value (1-5 stars) */
+    rating: number;
+    /** Review text or null if not provided */
+    review: string | null;
+    /** Number of users who found this rating helpful */
+    helpful: number;
+    /** ISO 8601 timestamp of when the rating was created */
+    createdAt: string;
+}
+/**
+ * Error codes specific to ratings API
+ */
+declare enum RatingsApiErrorCode {
+    /** User has already rated this skill */
+    DUPLICATE_RATING = "DUPLICATE_RATING",
+    /** Rating value is invalid (not 1-5) */
+    INVALID_RATING_VALUE = "INVALID_RATING_VALUE",
+    /** Skill not found */
+    SKILL_NOT_FOUND = "SKILL_NOT_FOUND",
+    /** Authentication required */
+    UNAUTHORIZED = "UNAUTHORIZED",
+    /** Network or server error */
+    NETWORK_ERROR = "NETWORK_ERROR",
+    /** Unknown error */
+    UNKNOWN_ERROR = "UNKNOWN_ERROR"
+}
+/**
+ * Custom error class for ratings API errors
+ */
+declare class RatingsApiError extends Error {
+    readonly code: RatingsApiErrorCode;
+    readonly statusCode?: number | undefined;
+    readonly details?: unknown | undefined;
+    constructor(message: string, code: RatingsApiErrorCode, statusCode?: number | undefined, details?: unknown | undefined);
+}
+/**
+ * Fetches ratings for a specific skill
+ *
+ * Retrieves a paginated list of ratings along with summary statistics
+ * and rating distribution. This endpoint does not require authentication.
+ *
+ * @param skillId - The unique identifier of the skill
+ * @param params - Optional parameters for pagination and sorting
+ * @returns Promise resolving to ratings list, summary, and pagination info
+ * @throws {RatingsApiError} If the request fails
+ *
+ * @example
+ * ```typescript
+ * // Fetch first page of ratings sorted by most recent
+ * const result = await getSkillRatings('skill-123', {
+ *   page: 1,
+ *   limit: 10,
+ *   sort: 'recent'
+ * });
+ *
+ * console.log(`Average rating: ${result.summary.avgRating}`);
+ * console.log(`Total ratings: ${result.summary.totalRatings}`);
+ * ```
+ */
+declare function getSkillRatings(skillId: string, params?: GetSkillRatingsParams): Promise<GetSkillRatingsResponse>;
+/**
+ * Creates a new rating for a skill
+ *
+ * Submits a rating (1-5 stars) and optional review for a skill.
+ * Requires authentication via Bearer token. Each user can only
+ * rate a skill once; attempting to rate again will result in a
+ * DUPLICATE_RATING error.
+ *
+ * @param skillId - The unique identifier of the skill to rate
+ * @param data - Rating data including userId, rating value, and optional review
+ * @param token - Bearer token for authentication
+ * @returns Promise resolving to the created rating
+ * @throws {RatingsApiError} If validation fails, user is unauthorized, or duplicate rating exists
+ *
+ * @example
+ * ```typescript
+ * // Create a 5-star rating with review
+ * const rating = await createRating(
+ *   'skill-123',
+ *   {
+ *     userId: 'user-456',
+ *     rating: 5,
+ *     review: 'Excellent skill! Very helpful for my workflow.'
+ *   },
+ *   'your-auth-token'
+ * );
+ *
+ * console.log(`Rating created with ID: ${rating.id}`);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Create a rating without review
+ * const rating = await createRating(
+ *   'skill-123',
+ *   { userId: 'user-456', rating: 4 },
+ *   'your-auth-token'
+ * );
+ * ```
+ */
+declare function createRating(skillId: string, data: CreateRatingData, token: string): Promise<CreateRatingResponse>;
+/**
+ * Checks if an error is a duplicate rating error
+ *
+ * Utility function to easily check if a rating creation failed
+ * because the user has already rated the skill.
+ *
+ * @param error - The error to check
+ * @returns True if the error indicates a duplicate rating
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await createRating(skillId, data, token);
+ * } catch (error) {
+ *   if (isDuplicateRatingError(error)) {
+ *     console.log('You have already rated this skill');
+ *   } else {
+ *     throw error;
+ *   }
+ * }
+ * ```
+ */
+declare function isDuplicateRatingError(error: unknown): boolean;
+/**
+ * Checks if an error is an authentication error
+ *
+ * @param error - The error to check
+ * @returns True if the error indicates unauthorized access
+ */
+declare function isUnauthorizedError(error: unknown): boolean;
+/**
+ * Checks if an error is a skill not found error
+ *
+ * @param error - The error to check
+ * @returns True if the error indicates the skill was not found
+ */
+declare function isSkillNotFoundError(error: unknown): boolean;
+/**
+ * Ratings API object for convenient access to all rating functions
+ *
+ * @example
+ * ```typescript
+ * import { ratingsApi } from './ratings-api';
+ *
+ * // Get ratings
+ * const ratings = await ratingsApi.getSkillRatings('skill-123');
+ *
+ * // Create rating
+ * const newRating = await ratingsApi.createRating('skill-123', data, token);
+ * ```
+ */
+declare const ratingsApi: {
+    getSkillRatings: typeof getSkillRatings;
+    createRating: typeof createRating;
+    isDuplicateRatingError: typeof isDuplicateRatingError;
+    isUnauthorizedError: typeof isUnauthorizedError;
+    isSkillNotFoundError: typeof isSkillNotFoundError;
+};
+
+/**
+ * Skills Marketplace API Client
+ *
+ * Provides API methods for interacting with the CCJK Skills Marketplace.
+ * All marketplace endpoints are public and do not require authentication.
+ *
+ * @module skills-marketplace-api
+ */
+
+/** Request options interface */
+interface RequestOptions {
+    /** AbortController signal for request cancellation */
+    signal?: AbortSignal;
+    /** Cache TTL in milliseconds. Set to 0 to disable caching */
+    cacheTtl?: number;
+    /** Force refresh, bypassing cache */
+    forceRefresh?: boolean;
+}
+/**
+ * Get skills from the marketplace with pagination and filtering
+ *
+ * @param params - Query parameters for filtering and pagination
+ * @param params.page - Page number (default: 1)
+ * @param params.limit - Items per page (default: 20, max: 100)
+ * @param params.category - Filter by category
+ * @param params.provider - Filter by provider
+ * @param params.sort - Sort order (popular, newest, updated, name)
+ * @param params.isOfficial - Filter official skills only
+ * @param params.isTrending - Filter trending skills only
+ * @param options - Request options (signal, cacheTtl, forceRefresh)
+ * @returns Paginated marketplace response with skills array
+ *
+ * @example
+ * ```typescript
+ * // Get first page of trending skills
+ * const result = await getMarketplace({ isTrending: true, limit: 10 })
+ * console.log(result.data) // Array of skills
+ * console.log(result.pagination) // Pagination info
+ *
+ * // With request cancellation
+ * const controller = new AbortController()
+ * const result = await getMarketplace({}, { signal: controller.signal })
+ * // Later: controller.abort()
+ * ```
+ */
+declare function getMarketplace(params?: MarketplaceParams, options?: RequestOptions): Promise<MarketplaceResponse>;
+/**
+ * Search skills in the marketplace
+ *
+ * @param params - Search parameters
+ * @param params.q - Search query (required)
+ * @param params.category - Filter by category
+ * @param params.provider - Filter by provider
+ * @param params.limit - Maximum results (default: 20)
+ * @param params.offset - Results offset for pagination (default: 0)
+ * @param options - Request options (signal, cacheTtl, forceRefresh)
+ * @returns Search results with matching skills
+ *
+ * @example
+ * ```typescript
+ * // Search for git-related skills
+ * const result = await searchSkills({ q: 'git', limit: 10 })
+ * console.log(result.data) // Array of matching skills
+ * console.log(result.total) // Total matches
+ *
+ * // Search with category filter
+ * const result = await searchSkills({
+ *   q: 'deploy',
+ *   category: 'devops',
+ *   limit: 5
+ * })
+ * ```
+ */
+declare function searchSkills(params: SearchParams, options?: RequestOptions): Promise<SearchResponse>;
+/**
+ * Get search suggestions based on partial query
+ *
+ * @param params - Suggestion parameters
+ * @param params.q - Partial search query (required)
+ * @param params.limit - Maximum suggestions (default: 10)
+ * @param options - Request options (signal, cacheTtl, forceRefresh)
+ * @returns Array of search suggestions
+ *
+ * @example
+ * ```typescript
+ * // Get suggestions as user types
+ * const suggestions = await getSearchSuggestions({ q: 'git', limit: 5 })
+ * console.log(suggestions.data) // ['git-commit', 'git-branch', ...]
+ * ```
+ */
+declare function getSearchSuggestions(params: SuggestionsParams, options?: RequestOptions): Promise<SuggestionsResponse>;
+/**
+ * Get trending search keywords
+ *
+ * @param params - Trending parameters
+ * @param params.limit - Maximum keywords (default: 10)
+ * @param options - Request options (signal, cacheTtl, forceRefresh)
+ * @returns Array of trending keywords with search counts
+ *
+ * @example
+ * ```typescript
+ * // Get top 5 trending keywords
+ * const trending = await getTrendingKeywords({ limit: 5 })
+ * console.log(trending.data) // [{ keyword: 'ai', count: 1234 }, ...]
+ * ```
+ */
+declare function getTrendingKeywords(params?: TrendingParams, options?: RequestOptions): Promise<TrendingResponse>;
+/**
+ * Clear the API response cache
+ *
+ * @example
+ * ```typescript
+ * // Clear all cached responses
+ * clearCache()
+ * ```
+ */
+declare function clearCache(): void;
+/**
+ * Get current cache size
+ *
+ * @returns Number of cached entries
+ *
+ * @example
+ * ```typescript
+ * console.log(`Cache has ${getCacheSize()} entries`)
+ * ```
+ */
+declare function getCacheSize(): number;
+/**
+ * Create an AbortController for request cancellation
+ *
+ * @returns AbortController instance
+ *
+ * @example
+ * ```typescript
+ * const controller = createAbortController()
+ *
+ * // Start request
+ * const promise = getMarketplace({}, { signal: controller.signal })
+ *
+ * // Cancel if needed
+ * controller.abort()
+ *
+ * // Handle cancellation
+ * try {
+ *   await promise
+ * } catch (error) {
+ *   if (error instanceof SkillsMarketplaceApiError && error.code === 'ABORT_ERROR') {
+ *     console.log('Request was cancelled')
+ *   }
+ * }
+ * ```
+ */
+declare function createAbortController(): AbortController;
+/**
+ * Skills Marketplace API client object
+ *
+ * Provides a unified interface for all marketplace API methods.
+ *
+ * @example
+ * ```typescript
+ * import { skillsMarketplaceApi } from './skills-marketplace-api'
+ *
+ * // Get marketplace skills
+ * const marketplace = await skillsMarketplaceApi.getMarketplace({ limit: 10 })
+ *
+ * // Search skills
+ * const results = await skillsMarketplaceApi.searchSkills({ q: 'git' })
+ *
+ * // Get suggestions
+ * const suggestions = await skillsMarketplaceApi.getSearchSuggestions({ q: 'de' })
+ *
+ * // Get trending
+ * const trending = await skillsMarketplaceApi.getTrendingKeywords()
+ *
+ * // Clear cache
+ * skillsMarketplaceApi.clearCache()
+ * ```
+ */
+declare const skillsMarketplaceApi: {
+    getMarketplace: typeof getMarketplace;
+    searchSkills: typeof searchSkills;
+    getSearchSuggestions: typeof getSearchSuggestions;
+    getTrendingKeywords: typeof getTrendingKeywords;
+    clearCache: typeof clearCache;
+    getCacheSize: typeof getCacheSize;
+    createAbortController: typeof createAbortController;
+};
+
+/**
+ * Telemetry reporter with batching
+ */
+declare class TelemetryReporter {
+    private client;
+    private config;
+    private events;
+    private flushTimer?;
+    private userId;
+    constructor(client: CloudClient, config?: Partial<TelemetryConfig>);
+    /**
+     * Generate or load anonymous user ID
+     */
+    private generateUserId;
+    /**
+     * Start periodic flush timer
+     */
+    private startFlushTimer;
+    /**
+     * Stop flush timer
+     */
+    private stopFlushTimer;
+    /**
+     * Check if telemetry is enabled
+     */
+    isEnabled(): boolean;
+    /**
+     * Track an event (non-blocking)
+     *
+     * @param type - Event type
+     * @param data - Additional event data
+     */
+    track(type: MetricType, data?: TelemetryEventData): void;
+    /**
+     * Track template download
+     */
+    trackTemplateDownload(templateId: string, templateType: string): void;
+    /**
+     * Track recommendation shown
+     */
+    trackRecommendationShown(recommendationId: string, category: string): void;
+    /**
+     * Track recommendation accepted
+     */
+    trackRecommendationAccepted(recommendationId: string, category: string): void;
+    /**
+     * Track analysis completed
+     */
+    trackAnalysisCompleted(projectType?: string, frameworks?: string[]): void;
+    /**
+     * Track error occurred
+     */
+    trackError(errorType: string, errorMessage?: string, context?: string): void;
+    /**
+     * Flush pending events to server (non-blocking)
+     * Errors are caught and logged silently
+     */
+    flush(): Promise<void>;
+    /**
+     * Send a batch of events (non-blocking with retry budget)
+     */
+    private sendBatch;
+    /**
+     * Send telemetry with retry budget and short timeout
+     * Non-blocking: failures are logged but not thrown
+     */
+    private sendWithRetry;
+    /**
+     * Stop telemetry and flush remaining events
+     */
+    stop(): Promise<void>;
+    /**
+     * Get current queue size
+     */
+    getQueueSize(): number;
+    /**
+     * Get telemetry status
+     */
+    getStatus(): {
+        enabled: boolean;
+        queueSize: number;
+        userId: string;
+    };
+    /**
+     * Report usage directly (non-blocking)
+     * Fire-and-forget with retry budget and short timeout
+     *
+     * @param report - Usage report to send
+     */
+    reportUsage(report: UsageReport): void;
+}
+/**
+ * Initialize telemetry
+ */
+declare function initializeTelemetry(client: CloudClient, config?: Partial<TelemetryConfig>): TelemetryReporter;
+/**
+ * Get global telemetry instance
+ */
+declare function getTelemetry(): TelemetryReporter | undefined;
+/**
+ * Stop global telemetry
+ */
+declare function stopTelemetry(): Promise<void>;
+/**
+ * Track event using global telemetry
+ */
+declare function trackEvent(type: MetricType, data?: TelemetryEventData): void;
+/**
+ * Telemetry utilities
+ */
+declare const telemetryUtils: {
+    /**
+     * Check if telemetry is enabled
+     */
+    isEnabled(): boolean;
+    /**
+     * Track with automatic error handling
+     */
+    trackSafe(type: MetricType, data?: TelemetryEventData): void;
+    /**
+     * Get telemetry status
+     */
+    getStatus(): {
+        enabled: boolean;
+        queueSize: number;
+        userId: string;
+    };
+};
+
+/**
+ * User Skills API Client
+ *
+ * API client for managing user's installed skills
+ * Base URL: https://api.claudehome.cn/api/v1
+ * Authentication: Bearer Token
+ */
+
+/**
+ * Request options for authenticated requests
+ */
+interface AuthRequestOptions {
+    /** Bearer token for authentication */
+    token: string;
+    /** AbortController signal for request cancellation */
+    signal?: AbortSignal;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeout?: number;
+}
+/**
+ * Get user's installed skills
+ *
+ * @param userId - User ID
+ * @param options - Authentication and request options
+ * @returns User's installed skills with quota information
+ *
+ * @example
+ * ```typescript
+ * const result = await getUserSkills('user123', { token: 'auth-token' })
+ * console.log(result.skills) // Array of installed skills
+ * console.log(result.quota) // Quota information
+ * ```
+ */
+declare function getUserSkills(userId: string, options: AuthRequestOptions): Promise<UserSkillsResponse>;
+/**
+ * Install a skill for a user
+ *
+ * @param userId - User ID
+ * @param request - Installation request with skill ID
+ * @param options - Authentication and request options
+ * @returns Installation result with updated quota
+ *
+ * @example
+ * ```typescript
+ * const result = await installSkill(
+ *   'user123',
+ *   { skillId: 'git-commit', userTier: 'pro' },
+ *   { token: 'auth-token' }
+ * )
+ * console.log(result.skillId) // Installed skill ID
+ * console.log(result.quota) // Updated quota
+ * ```
+ */
+declare function installSkill(userId: string, request: InstallSkillRequest, options: AuthRequestOptions): Promise<InstallResponse>;
+/**
+ * Uninstall a skill for a user
+ *
+ * @param userId - User ID
+ * @param skillId - Skill ID to uninstall
+ * @param options - Authentication and request options
+ * @returns Uninstallation result with updated quota
+ *
+ * @example
+ * ```typescript
+ * const result = await uninstallSkill(
+ *   'user123',
+ *   'git-commit',
+ *   { token: 'auth-token' }
+ * )
+ * console.log(result.skillId) // Uninstalled skill ID
+ * console.log(result.quota) // Updated quota
+ * ```
+ */
+declare function uninstallSkill(userId: string, skillId: string, options: AuthRequestOptions): Promise<UninstallResponse>;
+/**
+ * Update a user's skill configuration
+ *
+ * @param userId - User ID
+ * @param skillId - Skill ID to update
+ * @param request - Update request with new configuration
+ * @param options - Authentication and request options
+ * @returns Updated skill information
+ *
+ * @example
+ * ```typescript
+ * const result = await updateSkill(
+ *   'user123',
+ *   'git-commit',
+ *   { isEnabled: true, config: { autoSign: true } },
+ *   { token: 'auth-token' }
+ * )
+ * console.log(result.isEnabled) // New enabled status
+ * console.log(result.config) // Updated configuration
+ * ```
+ */
+declare function updateSkill(userId: string, skillId: string, request: UpdateSkillRequest, options: AuthRequestOptions): Promise<UpdateResponse>;
+/**
+ * Get personalized skill recommendations for a user
+ *
+ * @param userId - User ID
+ * @param params - Recommendation parameters
+ * @param options - Authentication and request options
+ * @returns Personalized skill recommendations
+ *
+ * @example
+ * ```typescript
+ * const result = await getRecommendations(
+ *   'user123',
+ *   { limit: 5, excludeInstalled: true },
+ *   { token: 'auth-token' }
+ * )
+ * console.log(result.recommendations) // Array of recommended skills
+ * console.log(result.basedOn) // Recommendation basis
+ * ```
+ */
+declare function getRecommendations(userId: string, params: RecommendationsParams | undefined, options: AuthRequestOptions): Promise<RecommendationsResponse>;
+/**
+ * Get user's quota information
+ *
+ * @param userId - User ID
+ * @param options - Authentication and request options
+ * @returns User's quota information
+ *
+ * @example
+ * ```typescript
+ * const quota = await getUserQuota('user123', { token: 'auth-token' })
+ * console.log(quota.used) // Number of installed skills
+ * console.log(quota.limit) // Maximum allowed skills
+ * console.log(quota.remaining) // Remaining slots
+ * ```
+ */
+declare function getUserQuota(userId: string, options: AuthRequestOptions): Promise<Quota>;
+/**
+ * Check if a user can install more skills
+ *
+ * @param quota - User's quota information
+ * @returns True if user can install more skills
+ *
+ * @example
+ * ```typescript
+ * const quota = await getUserQuota('user123', { token: 'auth-token' })
+ * if (canInstallMore(quota)) {
+ *   console.log('User can install more skills')
+ * }
+ * ```
+ */
+declare function canInstallMore(quota: Quota): boolean;
+/**
+ * Get quota usage percentage
+ *
+ * @param quota - User's quota information
+ * @returns Usage percentage (0-100)
+ *
+ * @example
+ * ```typescript
+ * const quota = await getUserQuota('user123', { token: 'auth-token' })
+ * const usage = getQuotaUsagePercentage(quota)
+ * console.log(`Quota usage: ${usage}%`)
+ * ```
+ */
+declare function getQuotaUsagePercentage(quota: Quota): number;
+/**
+ * Check if a skill is installed
+ *
+ * @param skills - User's installed skills
+ * @param skillId - Skill ID to check
+ * @returns True if skill is installed
+ *
+ * @example
+ * ```typescript
+ * const result = await getUserSkills('user123', { token: 'auth-token' })
+ * if (isSkillInstalled(result.skills, 'git-commit')) {
+ *   console.log('Skill is installed')
+ * }
+ * ```
+ */
+declare function isSkillInstalled(skills: UserSkill[], skillId: string): boolean;
+/**
+ * Get enabled skills
+ *
+ * @param skills - User's installed skills
+ * @returns Array of enabled skills
+ *
+ * @example
+ * ```typescript
+ * const result = await getUserSkills('user123', { token: 'auth-token' })
+ * const enabled = getEnabledSkills(result.skills)
+ * console.log(`${enabled.length} skills are enabled`)
+ * ```
+ */
+declare function getEnabledSkills(skills: UserSkill[]): UserSkill[];
+/**
+ * Get disabled skills
+ *
+ * @param skills - User's installed skills
+ * @returns Array of disabled skills
+ *
+ * @example
+ * ```typescript
+ * const result = await getUserSkills('user123', { token: 'auth-token' })
+ * const disabled = getDisabledSkills(result.skills)
+ * console.log(`${disabled.length} skills are disabled`)
+ * ```
+ */
+declare function getDisabledSkills(skills: UserSkill[]): UserSkill[];
+/**
+ * Sort skills by usage count
+ *
+ * @param skills - User's installed skills
+ * @param order - Sort order (default: 'desc')
+ * @returns Sorted array of skills
+ *
+ * @example
+ * ```typescript
+ * const result = await getUserSkills('user123', { token: 'auth-token' })
+ * const sorted = sortByUsage(result.skills)
+ * console.log('Most used skill:', sorted[0].name)
+ * ```
+ */
+declare function sortByUsage(skills: UserSkill[], order?: 'asc' | 'desc'): UserSkill[];
+/**
+ * Sort skills by last used date
+ *
+ * @param skills - User's installed skills
+ * @param order - Sort order (default: 'desc')
+ * @returns Sorted array of skills
+ *
+ * @example
+ * ```typescript
+ * const result = await getUserSkills('user123', { token: 'auth-token' })
+ * const sorted = sortByLastUsed(result.skills)
+ * console.log('Recently used skill:', sorted[0].name)
+ * ```
+ */
+declare function sortByLastUsed(skills: UserSkill[], order?: 'asc' | 'desc'): UserSkill[];
+/**
+ * User Skills API client object
+ *
+ * Provides a unified interface for all user skills API methods.
+ *
+ * @example
+ * ```typescript
+ * import { userSkillsApi } from './user-skills-api'
+ *
+ * const options = { token: 'auth-token' }
+ *
+ * // Get user's skills
+ * const skills = await userSkillsApi.getUserSkills('user123', options)
+ *
+ * // Install a skill
+ * const result = await userSkillsApi.installSkill(
+ *   'user123',
+ *   { skillId: 'git-commit' },
+ *   options
+ * )
+ *
+ * // Update skill
+ * await userSkillsApi.updateSkill(
+ *   'user123',
+ *   'git-commit',
+ *   { isEnabled: true },
+ *   options
+ * )
+ *
+ * // Uninstall skill
+ * await userSkillsApi.uninstallSkill('user123', 'git-commit', options)
+ *
+ * // Get recommendations
+ * const recommendations = await userSkillsApi.getRecommendations(
+ *   'user123',
+ *   { limit: 5 },
+ *   options
+ * )
+ * ```
+ */
+declare const userSkillsApi: {
+    getUserSkills: typeof getUserSkills;
+    installSkill: typeof installSkill;
+    uninstallSkill: typeof uninstallSkill;
+    updateSkill: typeof updateSkill;
+    getRecommendations: typeof getRecommendations;
+    getUserQuota: typeof getUserQuota;
+    canInstallMore: typeof canInstallMore;
+    getQuotaUsagePercentage: typeof getQuotaUsagePercentage;
+    isSkillInstalled: typeof isSkillInstalled;
+    getEnabledSkills: typeof getEnabledSkills;
+    getDisabledSkills: typeof getDisabledSkills;
+    sortByUsage: typeof sortByUsage;
+    sortByLastUsed: typeof sortByLastUsed;
+};
+
+/**
+ * Fallback Cloud Client with Local Fallback Support
+ *
+ * When the API is unavailable, falls back to local recommendations
+ */
+declare class FallbackCloudClient {
+    private client;
+    private fallbackEnabled;
+    constructor(client: CloudClient, fallbackEnabled?: boolean);
+    /**
+     * Analyze project with fallback
+     */
+    analyzeProject(request: ProjectAnalysisRequest): Promise<ProjectAnalysisResponse>;
+    /**
+     * Get template with fallback
+     */
+    getTemplate(id: string, language?: string): Promise<TemplateResponse>;
+    /**
+     * Get batch templates with fallback
+     */
+    getBatchTemplates(request: BatchTemplateRequest): Promise<BatchTemplateResponse$1>;
+    /**
+     * Report usage (no fallback)
+     */
+    reportUsage(report: UsageReport): Promise<UsageReportResponse>;
+    /**
+     * Health check (no fallback)
+     */
+    healthCheck(): Promise<HealthCheckResponse>;
+    /**
+     * Get local fallback recommendations
+     */
+    private getLocalRecommendations;
+    /**
+     * Get local fallback template
+     */
+    private getLocalTemplate;
+    /**
+     * Get local fallback batch templates
+     */
+    private getLocalBatchTemplates;
+    /**
+     * Detect project type
+     */
+    private detectProjectType;
+    /**
+     * Detect frameworks
+     */
+    private detectFrameworks;
+}
+/**
+ * Create a complete cloud client with all features
+ */
+declare function createCompleteCloudClient(config?: Partial<CloudClientConfig>): FallbackCloudClient;
+
+export { AiderTool, BaseCodeTool, BaseError, CachedCloudClient, ClaudeCodeTool, ClineTool, CloudCache, CloudClient, CloudClientError, CloudError, CloudErrorCode, CloudErrorFactory, CodexTool, ConfigManager, ConfigValidator, ConfigurationError, ContinueTool, CursorTool, FallbackCloudClient, InternalError, Logger, Mutex, NotFoundError, RatingsApiError, RatingsApiErrorCode, RetryableCloudClient, Semaphore, TelemetryReporter, TemplatesClient, TimeoutError, ToolFactory, ToolRegistry, UnauthorizedError, ValidationError, index$6 as array, assert, assertDefined, index$5 as async, batchProcessFiles, camelCase, canInstallMore, capitalize, chunk, index$4 as command, commandExists$1 as commandExists, config, convertBatchTemplateResponse, convertConfig, convertParameterDefault, convertProjectAnalysisResponse, convertRecommendation, convertTemplate, convertTemplateParameter, copyFile, countLines, createCloudClient, createCompleteCloudClient, createConfigManager, createLogger, createRating, createTemplatesClient, createTool, createValidator, debounce, deepClone, deepMerge, deleteDir, deleteFile, difference, ensureDir, index$3 as error, executeCommand, executeCommandStream, exists, extractDisplayName, extractString, flatten, flatten$1 as flattenArray, formatError, formatErrorForLogging, index$2 as fs, generateCompactWelcome, generateRecommendations, generateWelcome, get, getArchitecture, getCacheDir, getCapabilitiesByType, getCapability, getCloudMcpRecommendations, getCloudRecommendations, getCloudRecommendedHooks, getCloudSkillRecommendations, getCommandPath, getCommandVersion, getCommunityHooks, getConfigDir, getDataDir, getDisabledSkills, getEnabledSkills, getErrorMessage, getFileInfo, getFileSize, getHomeDir, getPlatform, getPlatformInfo, getQuotaUsagePercentage, getRecommendations, getRegistry, getRetryDelay, getSkillRatings, getTelemetry, getTempDir, getTemplatesClient, getUserQuota, getUserSkills, handleCloudError, has, i18nHelpers, initializeTelemetry, installSkill, intersection, isArray, isAuthError, isBoolean, isDefined, isDirectory, isDuplicateRatingError, isEmail, isFile, isLargeFile, isLinux, isMacOS, isNumber, isObject, isRateLimitError, isRecommendationConfig, isRetryableError, isRetryableErrorCode, isSkillInstalled, isSkillNotFoundError, isString, isTelemetryEventData, isTemplateParameterValue, isURL, isUnauthorizedError, isUnix, isWindows, kebabCase, listDirs, listFiles, logger, logger$2 as loggerUtils, moveFile, normalizeRecommendation, normalizeRecommendations, index$1 as object, omit, parallelLimit, partition, pascalCase, pick, platform, processLargeFile, processLineByLine, ratingsApi, readFile, readJSON, retry, retryUtils, scanCapabilities, sequence, set, shuffle, skillsMarketplaceApi, sleep, slugify, snakeCase, sortByLastUsed, sortByUsage, stopTelemetry, streamJSON, streamWriteJSON, index as string, submitHookAnalytics, telemetryUtils, template, throttle, timeout, trackEvent, truncate, tryCatch, tryCatchAsync, unflatten, uninstallSkill, union, unique, updateSkill, userSkillsApi, validateBatchTemplateRequest, validateProjectAnalysisRequest, validateUsageReport, validation, validators, waitFor, withRetry, wrapError, writeFile, writeJSON };
+export type { AgentConfig, AnalysisCompletedData, AuthRequestOptions, BatchTelemetryData, BatchTemplateRequest, BatchTemplateResponse$1 as BatchTemplateResponse, CacheEntry, Capability, CapabilityScanResult, CapabilityStatus, CapabilityType, ChunkProcessorOptions, CloudErrorMetadata, CreateRatingData, CreateRatingResponse, ErrorOccurredData, ExecutionResult, FileInfo, GetSkillRatingsParams, GetSkillRatingsResponse, HealthCheckResponse, HookConfig, IChatTool, ICodeGenTool, ICodeTool, IFileEditTool, InstallStatus, McpServerConfig, MetricType, MultilingualString, ProjectAnalysisRequest, ProjectAnalysisResponse, RatingSortOption, RawBatchTemplateResponse, RawProjectAnalysisResponse, RawRecommendation, RawTemplate, Recommendation, RecommendationAcceptedData, RecommendationConfig, RecommendationShownData, SkillConfig, StreamProcessorOptions, TelemetryEventData, TemplateDownloadData, TemplateParameter, TemplateParameterValue, TemplateResponse, TemplateType$1 as TemplateType, ToolCapabilities, ToolConfig, ToolMetadata, UsageReport, UsageReportResponse, WelcomeOptions, WorkflowConfig };