import { BaseModel } from '../core/balancy-model.class';
/**
 * Logic class for SmartObjects Conditions.
 * Provides methods to evaluate condition status, subscribe to changes, and get timing information.
 *
 * @example
 * ```typescript
 * // Check if condition passes
 * const passes = condition.canPass();
 *
 * // Subscribe to status changes
 * condition.subscribeForStatusChange((passed) => {
 *   console.log(`Condition ${condition.unnyId} is now ${passed ? 'active' : 'inactive'}`);
 * });
 *
 * // Get timing information
 * const secondsLeft = condition.getSecondsLeftBeforeDeactivation();
 * const secondsUntil = condition.getSecondsBeforeActivation();
 *
 * // Cleanup when done
 * condition.unsubscribeFromStatusChange();
 * ```
 */
export declare class SmartObjectsConditionsLogic extends BaseModel {
    private static callbackRegistry;
    private isSubscribed;
    private boundStaticCallback?;
    /**
     * Evaluates whether this condition currently passes for the active user.
     *
     * @returns True if condition passes, false otherwise
     *
     * @example
     * ```typescript
     * const condition: Logic = ...; // Get condition instance
     * if (condition.canPass()) {
     *   console.log('Condition is currently passing');
     * }
     * ```
     */
    canPass(): boolean;
    /**
     * Subscribes to condition status changes. Callback will be invoked
     * whenever the condition's pass/fail status changes.
     *
     * Note: Only one subscription per condition is supported. Calling this multiple times
     * will replace the previous callback.
     *
     * @param callback Function to invoke with new status (true = passed, false = failed)
     *
     * @example
     * ```typescript
     * condition.subscribeForStatusChange((passed) => {
     *   if (passed) {
     *     console.log('Condition activated!');
     *   } else {
     *     console.log('Condition deactivated!');
     *   }
     * });
     * ```
     */
    subscribeForStatusChange(callback: (passed: boolean) => void): void;
    /**
     * Unsubscribes from condition status changes.
     *
     * @example
     * ```typescript
     * // Subscribe
     * condition.subscribeForStatusChange(callback);
     *
     * // Later, when done
     * condition.unsubscribeFromStatusChange();
     * ```
     */
    unsubscribeFromStatusChange(): void;
    /**
     * Gets the number of seconds remaining before this condition deactivates.
     *
     * @returns Seconds until deactivation, -1 if not currently active, Number.MAX_SAFE_INTEGER if indefinite
     *
     * @example
     * ```typescript
     * const secondsLeft = condition.getSecondsLeftBeforeDeactivation();
     * if (secondsLeft > 0 && secondsLeft < Number.MAX_SAFE_INTEGER) {
     *   console.log(`Condition will deactivate in ${secondsLeft} seconds`);
     * } else if (secondsLeft === -1) {
     *   console.log('Condition is not currently active');
     * } else {
     *   console.log('Condition is active indefinitely');
     * }
     * ```
     */
    getSecondsLeftBeforeDeactivation(): number;
    /**
     * Gets the number of seconds until this condition will activate.
     *
     * @param ignoreTriggers If true, ignores trigger-based conditions
     * @returns Seconds until activation, -1 if already active, Number.MAX_SAFE_INTEGER if never/trigger-based
     *
     * @example
     * ```typescript
     * const secondsUntil = condition.getSecondsBeforeActivation();
     * if (secondsUntil > 0 && secondsUntil < Number.MAX_SAFE_INTEGER) {
     *   console.log(`Condition will activate in ${secondsUntil} seconds`);
     * } else if (secondsUntil === -1) {
     *   console.log('Condition is already active');
     * } else {
     *   console.log('Condition requires a trigger or will never activate');
     * }
     *
     * // Ignore trigger-based conditions
     * const secondsUntilNoTriggers = condition.getSecondsBeforeActivation(true);
     * ```
     */
    getSecondsBeforeActivation(ignoreTriggers?: boolean): number;
    /**
     * Static callback invoked from C++ when condition status changes.
     * Dispatches to the appropriate instance callback.
     * @private
     */
    private static onConditionStatusChanged;
    /**
     * Cleanup when condition is destroyed.
     * Automatically unsubscribes from status changes.
     * @override
     */
    cleanUp(parentWasDestroyed: boolean): void;
    static getFileName(): string;
}
//# sourceMappingURL=models.smartobjects.conditions.logic.class.d.ts.map