import * as i0 from '@angular/core';
import { TemplateRef, OnChanges, OnInit, OnDestroy, AfterContentInit, EventEmitter, SimpleChanges, ComponentRef, AfterViewInit, ElementRef } from '@angular/core';
import { Subscription } from 'rxjs';
import { BooleanInput } from '@angular/cdk/coercion';
import { EuiIconSvgComponent } from '@eui/components/eui-icon';

declare class EuiTemplateDirective<T = never> {
    template: TemplateRef<T>;
    type: string;
    name: string;
    getType(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiTemplateDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuiTemplateDirective<any>, "[euiTemplate]", never, { "type": { "alias": "type"; "required": false; }; "name": { "alias": "euiTemplate"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * @description
 * A tooltip is a text box that displays addition information when a user hovers over, clicks or gives focus to a UI element such as an icon, a highlighted word or a button.
 *
 * The information should be contextual, useful and non-essential.
 *
 */
declare class EuiTooltipDirective implements OnChanges, OnInit, OnDestroy {
    /**
     * Sets the `data-e2e` attribute for the host element.
     *
     * @default 'eui-tooltip'
     */
    e2eAttr: string;
    /**
     * Sets the delay for the tooltip to be visible.
     *
     * @default 0
     */
    showDelay: number;
    /**
     * Sets the delay for the tooltip to be hidden
     *
     * @default 0
     */
    hideDelay: number;
    /**
     * Sets the alignment of the content in the tooltip.
     *
     * @default 'center''
     */
    contentAlignment: 'left' | 'right' | 'center' | 'justify';
    /**
     * Sets the position of the tooltip relative to its trigger element.
     *
     * @default 'center''
     */
    position: 'left' | 'right' | 'above' | 'below' | 'before' | 'after' | string;
    /**
     * Whether the tooltip is disabled.
     *
     * @default false (enable)
     */
    isDisabled: boolean;
    /**
     * Tooltip content.
     */
    tooltipContent: string;
    /**
     * Whether the tooltip has a Primary state.
     *
     * @default false
     */
    euiTooltipPrimary: boolean;
    /**
     * Whether the tooltip has a Secondary state.
     *
     * @default false
     */
    euiTooltipSecondary: boolean;
    /**
     * Whether the tooltip has Info state.
     *
     * @default false
     */
    euiTooltipInfo: boolean;
    /**
     * Whether the tooltip has a Success state.
     *
     * @default false
     */
    euiTooltipSuccess: boolean;
    /**
     * Whether the tooltip has a Warning state.
     *
     * @default false
     */
    euiTooltipWarning: boolean;
    /**
     * Whether the tooltip has a Danger state.
     *
     * @default false
     */
    euiTooltipDanger: boolean;
    /**
     * Whether the tooltip has Accent state.
     *
     * @default false
     */
    euiTooltipAccent: boolean;
    private originX;
    private originY;
    private overlayX;
    private overlayY;
    private fallbackOriginX;
    private fallbackOriginY;
    private fallbackOverlayX;
    private fallbackOverlayY;
    private overlayRef;
    private destroy$;
    private isOpen$;
    private mouseleaveSubscription;
    private blurSubscription;
    private showDelaySubscription;
    private positionStrategySubscription;
    private tooltipInstance;
    private overlay;
    private host;
    ngOnChanges(): void;
    ngOnInit(): void;
    ngOnDestroy(): void;
    mouseEntering(event: MouseEvent): void;
    focused(event: FocusEvent): void;
    /**
     * Returns the current open state.
     *
     * @returns {boolean} `true` if the element is open, otherwise `false`.
     */
    get isOpen(): boolean;
    /**
     * Method that shows a tooltip.
     *
     * @param origin Origin of the tooltip. Where it will be displayed.
     */
    show(origin?: EventTarget): void;
    /**
     * Method that closes a tooltip.
     */
    hide(): void;
    protected onEscapePressed(event: KeyboardEvent): void;
    /**
     * Generates and returns the tooltip configuration based on the defined tooltip properties.
     *
     * @returns {EuiTooltipInterface} The tooltip configuration object, including attributes used in container component.
     */
    private getTooltipConfig;
    /**
     * Determines and returns the tooltip's position based on the overlay's connection pair.
     *
     * @param {ConnectedOverlayPositionChange} overlayPosition - The overlay position change event.
     * @returns {string} The calculated position (`'above'`, `'below'`, `'left'`, or `'right'`).
     */
    private getPosition;
    /**
     * Sets the position-related properties based on the current `position` value.
     */
    private setPosition;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiTooltipDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuiTooltipDirective, "[euiTooltip]", ["euiTooltip"], { "e2eAttr": { "alias": "e2eAttr"; "required": false; }; "showDelay": { "alias": "showDelay"; "required": false; }; "hideDelay": { "alias": "hideDelay"; "required": false; }; "contentAlignment": { "alias": "contentAlignment"; "required": false; }; "position": { "alias": "position"; "required": false; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; "tooltipContent": { "alias": "euiTooltip"; "required": false; }; "euiTooltipPrimary": { "alias": "euiTooltipPrimary"; "required": false; }; "euiTooltipSecondary": { "alias": "euiTooltipSecondary"; "required": false; }; "euiTooltipInfo": { "alias": "euiTooltipInfo"; "required": false; }; "euiTooltipSuccess": { "alias": "euiTooltipSuccess"; "required": false; }; "euiTooltipWarning": { "alias": "euiTooltipWarning"; "required": false; }; "euiTooltipDanger": { "alias": "euiTooltipDanger"; "required": false; }; "euiTooltipAccent": { "alias": "euiTooltipAccent"; "required": false; }; }, {}, never, never, true, never>;
    static ngAcceptInputType_showDelay: unknown;
    static ngAcceptInputType_hideDelay: unknown;
    static ngAcceptInputType_isDisabled: unknown;
    static ngAcceptInputType_euiTooltipPrimary: unknown;
    static ngAcceptInputType_euiTooltipSecondary: unknown;
    static ngAcceptInputType_euiTooltipInfo: unknown;
    static ngAcceptInputType_euiTooltipSuccess: unknown;
    static ngAcceptInputType_euiTooltipWarning: unknown;
    static ngAcceptInputType_euiTooltipDanger: unknown;
    static ngAcceptInputType_euiTooltipAccent: unknown;
}

/**
 * @description
 * A directive that adds maxLength functionality to input and textarea elements with visual feedback.
 * It shows the remaining characters count and provides visual indication when the limit is reached.
 *
 * @selector input[euiMaxlength], textarea[euiMaxlength], [ngModel][euiMaxlength], [formControlName][euiMaxlength]
 *
 * @example
 * ```HTML
 * <!-- Basic usage -->
 * <input [euiMaxlength]="50">
 *
 * <!-- With form control -->
 * <input [formControlName]="'name'" [euiMaxlength]="100">
 *
 * <!-- Hide maxlength indicator -->
 * <textarea [euiMaxlength]="200" [isShowMaxlength]="false"></textarea>
 * ```
 *
 * @publicApi
 */
declare class EuiMaxLengthDirective implements AfterContentInit, OnDestroy, OnChanges {
    /**
     * @description
     * It accepts number values to indicate the maxLength of an input. To reset or disable it set the value to null.
     * NULL value will remove any MaxLength indicator even if another input like isShowMaxlength equals true.
     */
    maxLength: number;
    /**
     * @description
     * Controls the visibility of the maxLength indicator.
     * When true, shows a counter with remaining characters.
     * When false, hides the counter but maintains the maxLength restriction.
     *
     * @default true
     */
    isShowMaxlength: boolean;
    /**
     * @description
     * Emits when the input value length reaches or exceeds the maxLength limit.
     * Emits true when a limit is reached, false when below limit.
     *
     * @emits {boolean} True when max length is reached, false otherwise
     */
    maxLengthReached: EventEmitter<boolean>;
    valueChangesSubscription: Subscription;
    private maxLengthSpan;
    private wrapper;
    private lengthCalcFn;
    private el;
    private renderer;
    private control;
    constructor();
    ngOnDestroy(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngAfterContentInit(): void;
    onChange(): void;
    onInput(): void;
    onPaste(event: ClipboardEvent): void;
    /**
     * Sets a custom function to calculate the length of the input value.
     * Useful for implementing custom length calculation logic (e.g., counting characters differently).
     *
     * @param fn Function that takes a string input and returns its calculated length
     *
     * @example
     * ```typescript
     * // Custom length calculation excluding spaces
     * directive.setLengthCalcFactory((value: string) => value.replace(/\s/g, '').length);
     * ```
     */
    setLengthCalcFactory(fn: (input: string) => number): void;
    /**
     * Calculates the maximum length for the input element based on current value or provided value.
     *
     * @param value Optional value to calculate max length against (overrides the current input value)
     * @returns {number} Calculated maximum length
     * @private
     */
    private calculateMaxLength;
    /**
     * @description
     * Refreshes the visual state of the maxLength indicator and updates input restrictions.
     * - Updates the remaining characters count
     * - Applies/removes error styling
     * - Emits maxLengthReached event
     * - Truncates value if it exceeds maxLength
     *
     * @private
     */
    private _refreshValue;
    /**
     * @description
     * Creates the maxLength indicator box in the DOM.
     * Wraps the input element and adds the counter span with appropriate styling.
     *
     * @private
     */
    private createMaxLengthBox;
    /**
     * @description
     * Removes the maxLength indicator box from the DOM.
     * Restores the original DOM structure by unwrapping the input element.
     *
     * @private
     */
    private destroyMaxLengthBox;
    /**
     * @description
     * Returns the current value of the input element.
     * Handles different update strategies when used with forms.
     *
     * @returns {string} Current input value
     * @private
     */
    private getValue;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiMaxLengthDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuiMaxLengthDirective, "    input[euiMaxlength],    textarea[euiMaxlength],    [ngModel][euiMaxlength],    [formControlName][euiMaxlength]", never, { "maxLength": { "alias": "euiMaxlength"; "required": false; }; "isShowMaxlength": { "alias": "isShowMaxlength"; "required": false; }; }, { "maxLengthReached": "maxLengthReached"; }, never, never, true, never>;
    static ngAcceptInputType_maxLength: unknown;
    static ngAcceptInputType_isShowMaxlength: unknown;
}

declare enum ConditionOperator {
    AND = "AND",
    OR = "OR"
}
/**
 * @description
 * A structural directive that conditionally renders content based on user permissions.
 * Similar to *ngIf, but checks against a permission service to determine visibility.
 *
 * @example
 * ```HTML
 * <!-- Single permission check -->
 * <div *euiHasPermission="['READ_USERS']">
 *   Content only visible to users with READ_USERS permission
 * </div>
 *
 * <!-- Multiple permission check (AND operation) -->
 * <div *euiHasPermission="['READ_USERS', 'WRITE_USERS']">
 *   Content only visible to users with both permissions
 * </div>
 *
 * <!-- Using OR operator -->
 * <div *euiHasPermission="['READ_USERS', 'WRITE_USERS']" operator='OR'">
 *	Content visible to users with either permission
 * </div>
 * ```
 *
 * @usageNotes
 * The directive performs an AND operation when multiple permissions are provided,
 * meaning all permissions must be granted for the content to be displayed.
 */
declare class EuiHasPermissionDirective {
    /**
     * @internal
     * Array storing the current permission requirements
     */
    private permissions;
    /**
     * @internal
     * Logical operator for permission checks (AND/OR). Defaults to AND.
     */
    private operator;
    /**
     * @internal
     * Flag tracking whether the content is currently hidden
     */
    private isHidden;
    /**
     * Sets the logical operator for permission checks.
     * Can be 'AND' (default) or 'OR'.
     * - 'AND': All permissions must be granted to display the content.
     * - 'OR': At least one permission must be granted to display the content.
     */
    set euiHasPermissionOperator(operator: ConditionOperator);
    /**
     * @input
     * @description
     * Sets the permissions required to display the content. Can be a single permission
     * string or an array of permission strings.
     *
     * @param val - Permission or array of permissions to check
     */
    set euiHasPermission(val: any);
    private templateRef;
    private viewContainer;
    private permissionService;
    /**
     * @internal
     * @description
     * Updates the view based on the current permission check results.
     * If permissions are granted, displays the content.
     * If permissions are not granted, hides the content.
     */
    private updateView;
    /**
     * @internal
     * @description
     * Checks if all required permissions are granted.
     * Uses AND logic - all permissions must be granted for the method to return true.
     *
     * @returns {boolean} True if all permissions are granted, false otherwise
     */
    private checkPermission;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiHasPermissionDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuiHasPermissionDirective, "[euiHasPermission]", never, { "euiHasPermissionOperator": { "alias": "euiHasPermissionOperator"; "required": false; }; "euiHasPermission": { "alias": "euiHasPermission"; "required": false; }; }, {}, never, never, true, never>;
}

declare class EuiScrollHandlerDirective implements OnInit {
    navIsFixed: boolean;
    appHeaderHeight: number;
    euiScrollHandler: boolean;
    private appWrapper;
    private appHeader;
    private document;
    ngOnInit(): void;
    onWindowScroll(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiScrollHandlerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuiScrollHandlerDirective, "[euiScrollHandler]", never, { "euiScrollHandler": { "alias": "euiScrollHandler"; "required": false; }; }, {}, never, never, true, never>;
    static ngAcceptInputType_euiScrollHandler: unknown;
}
declare class EuiScrollHandlerElementDirective {
    euiScrollHandlerElement: string;
    toggleClass: string;
    toggleActiveHeight: number;
    navIsFixed: boolean;
    private document;
    onWindowScroll(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiScrollHandlerElementDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuiScrollHandlerElementDirective, "[euiScrollHandlerElement]", never, { "euiScrollHandlerElement": { "alias": "euiScrollHandlerElement"; "required": false; }; "toggleClass": { "alias": "toggleClass"; "required": false; }; "toggleActiveHeight": { "alias": "toggleActiveHeight"; "required": false; }; }, {}, never, never, true, never>;
    static ngAcceptInputType_toggleActiveHeight: unknown;
}

declare class EuiSmoothScrollToDirective {
    targetElement: any;
    scrollTo: string;
    duration: number;
    offset: number;
    easing: string;
    callbackBefore: any;
    callbackAfter: any;
    containerId: string;
    middleAlign: any;
    onClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiSmoothScrollToDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuiSmoothScrollToDirective, "[euiScrollTo]", never, { "scrollTo": { "alias": "euiScrollTo"; "required": false; }; "duration": { "alias": "duration"; "required": false; }; "offset": { "alias": "offset"; "required": false; }; "easing": { "alias": "easing"; "required": false; }; "callbackBefore": { "alias": "callbackBefore"; "required": false; }; "callbackAfter": { "alias": "callbackAfter"; "required": false; }; "containerId": { "alias": "containerId"; "required": false; }; "middleAlign": { "alias": "middleAlign"; "required": false; }; }, {}, never, never, true, never>;
    static ngAcceptInputType_duration: unknown;
    static ngAcceptInputType_offset: unknown;
}
declare class EuiSmoothScrollDirective implements OnInit {
    private platformId;
    private el;
    scrollIf: boolean;
    duration: number;
    offset: number;
    easing: string;
    callbackBefore: any;
    callbackAfter: any;
    containerId: string;
    scrollOnClick: boolean;
    middleAlign: any;
    onClick(target: any): void;
    ngOnInit(): void;
    private scroll;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiSmoothScrollDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuiSmoothScrollDirective, "[euiSmoothScroll]", never, { "scrollIf": { "alias": "scrollIf"; "required": false; }; "duration": { "alias": "duration"; "required": false; }; "offset": { "alias": "offset"; "required": false; }; "easing": { "alias": "easing"; "required": false; }; "callbackBefore": { "alias": "callbackBefore"; "required": false; }; "callbackAfter": { "alias": "callbackAfter"; "required": false; }; "containerId": { "alias": "containerId"; "required": false; }; "scrollOnClick": { "alias": "scrollOnClick"; "required": false; }; "middleAlign": { "alias": "middleAlign"; "required": false; }; }, {}, never, never, true, never>;
    static ngAcceptInputType_duration: unknown;
    static ngAcceptInputType_offset: unknown;
    static ngAcceptInputType_scrollOnClick: unknown;
}

declare class EuiLoadingDirective implements OnChanges {
    euiLoading: boolean;
    get readonly(): any;
    set readonly(v: BooleanInput);
    get cssClasses(): string;
    set cssClasses(value: string);
    protected _loadingIcon: ComponentRef<EuiIconSvgComponent>;
    private _euiUFlexWrapper;
    private _cssClasses;
    private _isReadonly;
    private _elementRef;
    private _viewContainerRef;
    private _renderer;
    private injector;
    ngOnChanges(changes: SimpleChanges): void;
    /**
     * create a flex wrapper for the input to hold the icon
     *
     * @private
     */
    private createFlexWrapper;
    /**
     * checks if the parent has a flexWrapper. This is used to avoid creating multiple flexWrappers
     *
     * @private
     */
    private doesParentHasAFlexWrapper;
    /**
     * removes the flexWrapper while keeping the input element intact
     *
     * @private
     */
    private removeFlexWrapper;
    /**
     * creates the loading icon component
     *
     * @private
     */
    private createLoadingIcon;
    /**
     * removes the loading icon component
     *
     * @private
     */
    private removeLoadingIcon;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiLoadingDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuiLoadingDirective, "[euiLoading]", never, { "euiLoading": { "alias": "euiLoading"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; }, {}, never, never, true, never>;
    static ngAcceptInputType_euiLoading: unknown;
}

declare class EuiClearableDirective implements OnChanges, AfterViewInit {
    euiClearable: boolean;
    get readonly(): any;
    set readonly(v: BooleanInput);
    get disabled(): any;
    set disabled(v: BooleanInput);
    get cssClasses(): string;
    set cssClasses(value: string);
    private _cssClasses;
    protected _clearableIcon: ComponentRef<EuiIconSvgComponent>;
    private _euiUFlexWrapper;
    private _isReadonly;
    private _disabled;
    private _elementRef;
    private _viewContainerRef;
    private _renderer;
    private injector;
    ngAfterViewInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    onKeyUpAndModelChange(value: any): void;
    private onClearableClicked;
    /**
     * creates the Clearable icon component
     *
     * @private
     */
    private createClearableIcon;
    /**
     * detach the Clearable icon from the view
     *
     * @private
     */
    private removeClearableIcon;
    /**
     * create a flex wrapper for the input to hold the icon
     *
     * @private
     */
    private createFlexWrapper;
    /**
     * checks if the parent has a flexWrapper. This is used to avoid creating multiple flexWrappers
     *
     * @private
     */
    private doesParentHasAFlexWrapper;
    /**
     * removes the flexWrapper while keeping the input element intact
     *
     * @private
     */
    private removeFlexWrapper;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiClearableDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuiClearableDirective, "input[euiClearable]", never, { "euiClearable": { "alias": "euiClearable"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
    static ngAcceptInputType_euiClearable: unknown;
}

type EuiResizablePosition = 'left' | 'right';
declare class EuiResizableDirective implements OnInit, OnDestroy {
    /**
     * Minimum width constraint for the resizable container in pixels.
     * Default is 0 if not specified.
     */
    euiResizableMinWidth: i0.InputSignalWithTransform<number, string | number>;
    /**
     * This is used to determine the placement of the resizable handle and the resizing behavior.
     * Possible values are 'left' or 'right'. Default is 'right'.
     */
    euiResizablePosition: i0.InputSignal<EuiResizablePosition>;
    styleWidth: number;
    styleMinWidth: number;
    styleMaxWidth: number;
    styleFlexBasisWidth: number;
    private _resizableBar;
    private destroy$;
    private _documentRef;
    private _elementRef;
    private _renderer;
    private _viewContainerRef;
    private cd;
    ngOnInit(): void;
    ngOnDestroy(): void;
    private _createResizableBar;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiResizableDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuiResizableDirective, "[euiResizable]", never, { "euiResizableMinWidth": { "alias": "euiResizableMinWidth"; "required": false; "isSignal": true; }; "euiResizablePosition": { "alias": "euiResizablePosition"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class EuiArrowKeyNavigableDirective {
    elementRef: ElementRef<any>;
    tabindex: string;
    isFocused: boolean;
    onFocus(): void;
    onBlur(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EuiArrowKeyNavigableDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<EuiArrowKeyNavigableDirective, "[euiArrowKeyNavigable]", never, {}, {}, never, never, true, never>;
}

export { ConditionOperator, EuiArrowKeyNavigableDirective, EuiClearableDirective, EuiHasPermissionDirective, EuiLoadingDirective, EuiMaxLengthDirective, EuiResizableDirective, EuiScrollHandlerDirective, EuiScrollHandlerElementDirective, EuiSmoothScrollDirective, EuiSmoothScrollToDirective, EuiTemplateDirective, EuiTooltipDirective };
export type { EuiResizablePosition };
//# sourceMappingURL=eui-components-directives.d.ts.map
