import type { LicenseConfig, LicenseState, Environment, EnforcementMode } from './types.js';
/**
 * Required features for different capabilities
 */
export declare const REQUIRED_FEATURES: {
    /** Feature required for basic client functionality */
    readonly CLIENT: "cybernetic-chatbot-client";
    /** Feature required for agentic capabilities (DOM automation, intent classification) */
    readonly AGENTIC: "agentic";
};
/**
 * License enforcement message shown in production when license is invalid
 */
/**
 * Detect current environment based on URL and other signals
 */
export declare function detectEnvironment(): Environment;
/**
 * Determine enforcement mode based on environment
 */
export declare function getEnforcementMode(environment: Environment): EnforcementMode;
/**
 * License Manager
 *
 * Manages license verification and enforcement for CyberneticClient.
 * - In development: Logs warnings to console (soft enforcement)
 * - In production: Appends warning to chatbot responses (hard enforcement)
 */
export declare class LicenseManager {
    private config;
    private state;
    private environment;
    private enforcementMode;
    private verificationPromise;
    private loggedMissingFeatures;
    constructor(config?: LicenseConfig);
    /**
     * Verify the license (async, caches result)
     */
    verify(): Promise<LicenseState>;
    /**
     * Get current license state (null if not yet verified)
     */
    getState(): LicenseState | null;
    /**
     * Check if license is valid or acceptable
     * Valid statuses: 'valid', 'eval'
     */
    isValid(): boolean;
    /**
     * Check if license requires action (expired, missing, invalid)
     */
    requiresAction(): boolean;
    /**
     * Get current environment
     */
    getEnvironment(): Environment;
    /**
     * Get current enforcement mode
     */
    getEnforcementMode(): EnforcementMode;
    /**
     * Process a response based on license status
     * In production with invalid license: appends warning to response
     * In development: logs warning (once) and returns response unchanged
     *
     * @param response - The chatbot response text
     * @returns Modified response (or original if license valid)
     */
    processResponse(response: string): string;
    /**
     * Get a human-readable license status message
     */
    getStatusMessage(): string;
    /**
     * Force re-verification (clears cached state)
     */
    reVerify(): Promise<LicenseState>;
    /**
     * Check if a specific feature is licensed
     *
     * @param feature - Feature name to check
     * @returns true if feature is present in license
     */
    hasFeature(feature: string): boolean;
    /**
     * Get all licensed features
     */
    getFeatures(): string[];
    /**
     * Check if client feature is licensed
     * Logs warning if not present (only once)
     *
     * @returns true if cybernetic-chatbot-client feature is present
     */
    checkClientFeature(): boolean;
    /**
     * Check if agentic feature is licensed
     * Logs warning if not present (only once)
     * Call this when attempting to use agentic capabilities
     *
     * @returns true if agentic feature is present
     */
    checkAgenticFeature(): boolean;
    /**
     * Check a feature and log if missing (only logs once per feature)
     */
    private checkFeatureWithLog;
    /**
     * Log missing feature warning with available features
     */
    private logMissingFeature;
    /**
     * Log license status based on enforcement mode
     */
    private logLicenseStatus;
}
/**
 * Create a pre-configured license manager and verify immediately
 */
export declare function createLicenseManager(config: LicenseConfig): Promise<LicenseManager>;
//# sourceMappingURL=licenseManager.d.ts.map