import { AfterContentChecked, ElementRef, OnDestroy, OnInit } from '@angular/core';
import { TooltipDirective } from './tooltip.directive';
import { BooleanInput } from '@angular/cdk/coercion';
import * as i0 from "@angular/core";
/**
 * Marks an element as the content element to be checked for overflow
 * when using spTruncatedWithTooltip directive.
 * Automatically registers itself with the parent TruncatedWithTooltipDirective.
 */
export declare class TruncatedWithTooltipContentElementDirective implements OnInit, OnDestroy {
    elementRef: ElementRef<HTMLElement>;
    private parentDirective?;
    constructor(elementRef: ElementRef<HTMLElement>, parentDirective?: TruncatedWithTooltipDirective | undefined);
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TruncatedWithTooltipContentElementDirective, [null, { optional: true; skipSelf: true; }]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TruncatedWithTooltipContentElementDirective, "[spTruncatedWithTooltipContent]", never, {}, {}, never, never, true, never>;
}
/**
 * Internal wrapper directive that extends TooltipDirective for use with truncated text functionality.
 *
 * This directive is designed to be used exclusively as a hostDirective within the
 * TruncatedWithTooltipDirective, enabling components to support automatic truncation tooltips
 * without conflicting with user-provided tooltip directives.
 *
 * Angular's hostDirectives feature allows a directive to be composed with other directives,
 * but if we used TooltipDirective directly in components that expose spTruncatedWithTooltip,
 * it would prevent users from also applying their own spTooltip directive to the same component.
 * By creating this internal wrapper, we maintain directive composition flexibility while
 * avoiding selector conflicts.
 */
export declare class TruncatedWithTooltipDirectiveInternal extends TooltipDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<TruncatedWithTooltipDirectiveInternal, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TruncatedWithTooltipDirectiveInternal, never, never, {}, {}, never, never, true, never>;
}
/**
 * Shows a tooltip with the text content of the host element, if the content is
 * overflowing. It also applies inline styles to hide the overflow and show the
 * ellipsis.
 *
 * @example <something spTruncatedWithTooltip>Overflow will always be truncated</something>
 * @example <something spTruncatedWithTooltip="someCondition">Overflow will be truncated only if someCondition is truthy</something>
 * @example
 * By using spTruncatedWithTooltipContent, you can detect overflow on a child element
 * while keeping the tooltip attached to the host element:
 * <div spTruncatedWithTooltip>
 *   <span spTruncatedWithTooltipContent>This text will be checked for overflow</span>
 * </div>
 */
export declare class TruncatedWithTooltipDirective implements AfterContentChecked {
    private tooltipDirective;
    private elementRef;
    /**
     * Whether the directive is enabled.
     */
    enabled: BooleanInput;
    /**
     * Optional content element marked with spTruncatedWithTooltipContent directive.
     * If not provided, the host element will be used.
     * This is automatically set when a child element has the directive.
     */
    contentElementDirective?: TruncatedWithTooltipContentElementDirective;
    /**
     * Registers a content element directive.
     * Called automatically by TruncatedWithTooltipContentElementDirective.
     * @internal
     */
    registerContentElement(directive: TruncatedWithTooltipContentElementDirective): void;
    /**
     * Unregisters the content element directive.
     * Called automatically by TruncatedWithTooltipContentElementDirective.
     * @internal
     */
    unregisterContentElement(): void;
    constructor(tooltipDirective: TruncatedWithTooltipDirectiveInternal, elementRef: ElementRef);
    ngAfterContentChecked(): void;
    private hasOverflow;
    static ɵfac: i0.ɵɵFactoryDeclaration<TruncatedWithTooltipDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TruncatedWithTooltipDirective, "[spTruncatedWithTooltip]", never, { "enabled": "spTruncatedWithTooltip"; }, {}, never, never, true, [{ directive: typeof TruncatedWithTooltipDirectiveInternal; inputs: {}; outputs: {}; }]>;
}