import * as i0 from '@angular/core';
import { HostListener, Directive, inject, TemplateRef, ViewContainerRef, Input, HostBinding, ChangeDetectorRef, input, computed, Component, ElementRef, DestroyRef } from '@angular/core';
import { BrowserUtilities } from '@sdcorejs/utils/fns';
import { I18nService } from '@sdcorejs/angular/i18n';
import { Router } from '@angular/router';
import { Overlay } from '@angular/cdk/overlay';
import { ComponentPortal } from '@angular/cdk/portal';
import { NgTemplateOutlet } from '@angular/common';

class SdScrollDirective {
    elementRef;
    renderer;
    #overflowX = 'hidden';
    #overflowY = 'auto';
    onMouseOver() {
        this.#overflowX = 'auto';
        // this.#overflowY = 'auto';
        this.renderer.setStyle(this.elementRef.nativeElement, 'overflow-x', this.#overflowX);
        // this.renderer.setStyle(this.elementRef.nativeElement, 'overflow-y', this.#overflowY);
    }
    onMouseOut() {
        this.#overflowX = 'hidden';
        this.renderer.setStyle(this.elementRef.nativeElement, 'overflow-x', this.#overflowX);
    }
    constructor(elementRef, renderer) {
        this.elementRef = elementRef;
        this.renderer = renderer;
    }
    ngOnInit() {
        this.renderer.setStyle(this.elementRef.nativeElement, '-webkit-transform', 'translate3d(0, 0, 0)');
        this.renderer.setStyle(this.elementRef.nativeElement, 'overflow-x', this.#overflowX);
        this.renderer.setStyle(this.elementRef.nativeElement, 'overflow-y', this.#overflowY);
    }
    scrollTop = () => {
        setTimeout(() => {
            if (this.elementRef?.nativeElement) {
                this.elementRef.nativeElement.scrollTop = 0;
            }
        }, 1);
    };
    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SdScrollDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive });
    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.17", type: SdScrollDirective, isStandalone: true, selector: "[sdScroll]", host: { listeners: { "mouseover": "onMouseOver()", "mouseout": "onMouseOut()" } }, ngImport: i0 });
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SdScrollDirective, decorators: [{
            type: Directive,
            args: [{
                    selector: '[sdScroll]',
                    standalone: true,
                }]
        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }], propDecorators: { onMouseOver: [{
                type: HostListener,
                args: ['mouseover']
            }], onMouseOut: [{
                type: HostListener,
                args: ['mouseout']
            }] } });

class SdDesktopDirective {
    #templateRef = inject(TemplateRef);
    #viewContainerRef = inject(ViewContainerRef);
    constructor() {
        if (!BrowserUtilities.isMobile()) {
            this.#viewContainerRef.createEmbeddedView(this.#templateRef);
        }
    }
    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SdDesktopDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.17", type: SdDesktopDirective, isStandalone: true, selector: "[sdDesktop]", ngImport: i0 });
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SdDesktopDirective, decorators: [{
            type: Directive,
            args: [{
                    selector: '[sdDesktop]',
                    standalone: true,
                }]
        }], ctorParameters: () => [] });

class SdMobileDirective {
    #templateRef = inject(TemplateRef);
    #viewContainerRef = inject(ViewContainerRef);
    constructor() {
        if (BrowserUtilities.isMobile()) {
            this.#viewContainerRef.createEmbeddedView(this.#templateRef);
        }
    }
    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SdMobileDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.17", type: SdMobileDirective, isStandalone: true, selector: "[sdMobile]", ngImport: i0 });
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SdMobileDirective, decorators: [{
            type: Directive,
            args: [{
                    selector: '[sdMobile]',
                    standalone: true,
                }]
        }], ctorParameters: () => [] });

class SdHoverCopyDirective {
    el;
    renderer;
    copyText;
    sdHoverCopyDisabled = false;
    #i18n = inject(I18nService);
    #copyButton = null;
    #tooltip;
    get #defaultTooltip() {
        return this.#i18n.t('core.directive.hover-copy.tooltip');
    }
    constructor(el, renderer) {
        this.el = el;
        this.renderer = renderer;
    }
    // https://onemount.atlassian.net/browse/SM-2287
    // Hiện tại khi sdHoverCopyDisabled = true, directive chỉ dùng opacity: 0 và pointerEvents: 'none' để ẩn nút, nhưng điều này không hoàn toàn ngăn chặn được việc click trong một số trường hợp.
    // Giải pháp: Remove khỏi DOM nếu column không được enable
    ngOnInit() {
        if (!this.sdHoverCopyDisabled) {
            this.#createAndAppendCopyButton();
        }
    }
    ngOnChanges(changes) {
        if (changes['sdHoverCopyDisabled']) {
            if (!this.sdHoverCopyDisabled) {
                // Enable - create and show button if not exists
                if (!this.#copyButton) {
                    this.#createAndAppendCopyButton();
                }
            }
            else {
                // Disable - remove button from DOM
                this.#removeCopyButton();
            }
        }
    }
    #createAndAppendCopyButton() {
        const parent = this.el.nativeElement;
        this.renderer.setStyle(parent, 'position', 'relative');
        // Create button
        this.#copyButton = this.renderer.createElement('button');
        this.renderer.setStyle(this.#copyButton, 'position', 'absolute');
        this.renderer.setStyle(this.#copyButton, 'top', '50%');
        this.renderer.setStyle(this.#copyButton, 'transform', 'translateY(-50%)');
        this.renderer.setStyle(this.#copyButton, 'right', '4px');
        this.renderer.setStyle(this.#copyButton, 'display', 'none');
        this.renderer.setStyle(this.#copyButton, 'z-index', '10');
        this.renderer.setStyle(this.#copyButton, 'background', 'transparent');
        this.renderer.setStyle(this.#copyButton, 'border', 'none');
        this.renderer.setStyle(this.#copyButton, 'cursor', 'pointer');
        this.renderer.setStyle(this.#copyButton, 'padding', '1px');
        this.renderer.setStyle(this.#copyButton, 'border-radius', '3px');
        this.renderer.setStyle(this.#copyButton, 'padding', '5px');
        this.renderer.setStyle(this.#copyButton, 'line-height', '1');
        this.renderer.setStyle(this.#copyButton, 'background-color', 'var(--sd-black100)');
        // Add inline SVG icon
        const svg = this.renderer.createElement('svg', 'svg');
        this.renderer.addClass(svg, 'text-secondary');
        this.renderer.setAttribute(svg, 'width', '14');
        this.renderer.setAttribute(svg, 'height', '14');
        this.renderer.setAttribute(svg, 'viewBox', '0 0 24 24');
        this.renderer.setAttribute(svg, 'fill', 'none');
        this.renderer.setAttribute(svg, 'xmlns', 'http://www.w3.org/2000/svg');
        const path = this.renderer.createElement('path', 'svg');
        this.renderer.setAttribute(path, 'd', 'M16 1H4C2.9 1 2 1.9 2 3V17H4V3H16V1ZM20 5H8C6.9 5 6 5.9 6 7V21C6 22.1 6.9 23 8 23H20C21.1 23 22 22.1 22 21V7C22 5.9 21.1 5 20 5ZM20 21H8V7H20V21Z');
        this.renderer.setAttribute(path, 'fill', 'currentColor');
        this.renderer.appendChild(svg, path);
        this.renderer.appendChild(this.#copyButton, svg);
        // Tooltip
        this.#tooltip = this.renderer.createElement('span');
        this.renderer.setProperty(this.#tooltip, 'innerText', this.#defaultTooltip);
        this.renderer.setStyle(this.#tooltip, 'position', 'absolute');
        this.renderer.setStyle(this.#tooltip, 'bottom', '100%');
        this.renderer.setStyle(this.#tooltip, 'left', '50%');
        this.renderer.setStyle(this.#tooltip, 'transform', 'translateX(-50%)');
        this.renderer.setStyle(this.#tooltip, 'marginBottom', '4px');
        this.renderer.setStyle(this.#tooltip, 'background', '#333');
        this.renderer.setStyle(this.#tooltip, 'color', '#fff');
        this.renderer.setStyle(this.#tooltip, 'padding', '2px 6px');
        this.renderer.setStyle(this.#tooltip, 'borderRadius', '4px');
        this.renderer.setStyle(this.#tooltip, 'fontSize', '12px');
        this.renderer.setStyle(this.#tooltip, 'whiteSpace', 'nowrap');
        this.renderer.setStyle(this.#tooltip, 'opacity', '0');
        this.renderer.setStyle(this.#tooltip, 'transition', 'opacity 0.2s');
        this.renderer.setStyle(this.#tooltip, 'pointerEvents', 'none');
        this.renderer.setStyle(this.#tooltip, 'userSelect', 'none');
        this.renderer.appendChild(this.#copyButton, this.#tooltip);
        this.renderer.appendChild(parent, this.#copyButton);
        // Listen click
        this.renderer.listen(this.#copyButton, 'click', () => {
            console.log('click', this.copyText);
            if (this.copyText && !this.sdHoverCopyDisabled) {
                BrowserUtilities.copyToClipboard(String(this.copyText));
                this.#showTooltip('Copied');
                setTimeout(() => this.#hideTooltip(), 1000);
            }
        });
    }
    #removeCopyButton() {
        if (this.#copyButton) {
            this.renderer.removeChild(this.el.nativeElement, this.#copyButton);
            this.#copyButton = null;
        }
    }
    #showTooltip(message) {
        this.renderer.setProperty(this.#tooltip, 'innerText', message);
        this.renderer.setStyle(this.#tooltip, 'opacity', '1');
    }
    #hideTooltip() {
        this.renderer.setProperty(this.#tooltip, 'innerText', this.#defaultTooltip);
        this.renderer.setStyle(this.#tooltip, 'opacity', '0');
    }
    onMouseEnter() {
        if (!this.sdHoverCopyDisabled && this.#copyButton) {
            this.renderer.setStyle(this.#copyButton, 'display', 'block');
        }
    }
    onMouseLeave() {
        if (this.#copyButton) {
            this.renderer.setStyle(this.#copyButton, 'display', 'none');
            this.#hideTooltip();
        }
    }
    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SdHoverCopyDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive });
    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.17", type: SdHoverCopyDirective, isStandalone: true, selector: "[sdHoverCopy]", inputs: { copyText: ["sdHoverCopy", "copyText"], sdHoverCopyDisabled: "sdHoverCopyDisabled" }, host: { listeners: { "mouseenter": "onMouseEnter()", "mouseleave": "onMouseLeave()" } }, usesOnChanges: true, ngImport: i0 });
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SdHoverCopyDirective, decorators: [{
            type: Directive,
            args: [{
                    selector: '[sdHoverCopy]',
                }]
        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }], propDecorators: { copyText: [{
                type: Input,
                args: [{ alias: 'sdHoverCopy', required: true }]
            }], sdHoverCopyDisabled: [{
                type: Input
            }], onMouseEnter: [{
                type: HostListener,
                args: ['mouseenter']
            }], onMouseLeave: [{
                type: HostListener,
                args: ['mouseleave']
            }] } });

class SdHrefDirective {
    #router = inject(Router);
    // Nhận vào url đã được xử lý (từ Pipe của bạn)
    url;
    // Tự động bind giá trị url vào thuộc tính href của thẻ <a>
    get href() {
        return this.url || 'javascript:;';
    }
    onClick(event) {
        if (!this.url)
            return;
        if (this.url.startsWith('http')) {
            // Nếu là link ngoài -> Mở tab mới và ngăn chặn hành vi mặc định của thẻ a (để không chuyển trang hiện tại)
            window.open(this.url, '_blank');
            event.preventDefault();
        }
        else {
            // Nếu là link nội bộ -> Ngăn chặn full-page reload, dùng Angular Router để điều hướng
            event.preventDefault();
            const [path, queryString] = this.url.split('?');
            // Bạn có thể dùng hàm SdUtilities.parseQueryParams của bạn ở đây,
            // hoặc dùng cách native URLSearchParams như sau:
            const params = new URLSearchParams(queryString || '');
            const queryParams = {};
            params.forEach((value, key) => (queryParams[key] = value));
            this.#router.navigate([path], { queryParams });
        }
    }
    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SdHrefDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.17", type: SdHrefDirective, isStandalone: true, selector: "a[sdHref]", inputs: { url: ["sdHref", "url"] }, host: { listeners: { "click": "onClick($event)" }, properties: { "attr.href": "this.href" } }, ngImport: i0 });
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SdHrefDirective, decorators: [{
            type: Directive,
            args: [{
                    selector: 'a[sdHref]',
                    standalone: true,
                }]
        }], propDecorators: { url: [{
                type: Input,
                args: ['sdHref']
            }], href: [{
                type: HostBinding,
                args: ['attr.href']
            }], onClick: [{
                type: HostListener,
                args: ['click', ['$event']]
            }] } });

var _a;
// Component dùng để instance cho overlay
class SdTooltipComponent {
    cdr = inject(ChangeDetectorRef);
    content = input.required(...(ngDevMode ? [{ debugName: "content" }] : /* istanbul ignore next */ []));
    color = input('#616161', ...(ngDevMode ? [{ debugName: "color" }] : /* istanbul ignore next */ []));
    isTemplate = computed(() => this.content() instanceof TemplateRef, ...(ngDevMode ? [{ debugName: "isTemplate" }] : /* istanbul ignore next */ []));
    templateContent = computed(() => (this.isTemplate() ? this.content() : null), ...(ngDevMode ? [{ debugName: "templateContent" }] : /* istanbul ignore next */ []));
    textContent = computed(() => (!this.isTemplate() ? this.content() : ''), ...(ngDevMode ? [{ debugName: "textContent" }] : /* istanbul ignore next */ []));
    onMouseEnterCb;
    onMouseLeaveCb;
    onMouseEnter() {
        this.onMouseEnterCb?.();
    }
    onMouseLeave() {
        this.onMouseLeaveCb?.();
    }
    triggerChangeDetection() {
        this.cdr.detectChanges();
    }
    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SdTooltipComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.17", type: SdTooltipComponent, isStandalone: true, selector: "sd-tooltip-container", inputs: { content: { classPropertyName: "content", publicName: "content", isSignal: true, isRequired: true, transformFunction: null }, color: { classPropertyName: "color", publicName: "color", isSignal: true, isRequired: false, transformFunction: null } }, host: { listeners: { "mouseenter": "onMouseEnter()", "mouseleave": "onMouseLeave()" } }, ngImport: i0, template: `
    <div
      class="c-sd-tooltip-container"
      [style.background-color]="color()">
      @if (isTemplate()) {
        <ng-container [ngTemplateOutlet]="templateContent()"></ng-container>
      } @else {
        <span class="c-sd-tooltip-text">{{ textContent() }}</span>
      }
    </div>
  `, isInline: true, styles: [".c-sd-tooltip-container{padding:6px 8px;border-radius:4px;color:#fff;font-size:12px;font-family:Roboto,Helvetica Neue,sans-serif;box-shadow:0 2px 4px -1px #0003,0 4px 5px #00000024,0 1px 10px #0000001f;max-width:250px;word-wrap:break-word;pointer-events:auto;-webkit-user-select:text;user-select:text}\n"], dependencies: [{ kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }] });
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SdTooltipComponent, decorators: [{
            type: Component,
            args: [{ selector: 'sd-tooltip-container', standalone: true, imports: [NgTemplateOutlet], template: `
    <div
      class="c-sd-tooltip-container"
      [style.background-color]="color()">
      @if (isTemplate()) {
        <ng-container [ngTemplateOutlet]="templateContent()"></ng-container>
      } @else {
        <span class="c-sd-tooltip-text">{{ textContent() }}</span>
      }
    </div>
  `, host: {
                        '(mouseenter)': 'onMouseEnter()',
                        '(mouseleave)': 'onMouseLeave()',
                    }, styles: [".c-sd-tooltip-container{padding:6px 8px;border-radius:4px;color:#fff;font-size:12px;font-family:Roboto,Helvetica Neue,sans-serif;box-shadow:0 2px 4px -1px #0003,0 4px 5px #00000024,0 1px 10px #0000001f;max-width:250px;word-wrap:break-word;pointer-events:auto;-webkit-user-select:text;user-select:text}\n"] }]
        }], propDecorators: { content: [{ type: i0.Input, args: [{ isSignal: true, alias: "content", required: true }] }], color: [{ type: i0.Input, args: [{ isSignal: true, alias: "color", required: false }] }] } });
// End
// Directive
class SdTooltipDirective {
    content = input.required({ ...(ngDevMode ? { debugName: "content" } : /* istanbul ignore next */ {}), alias: 'sdTooltip' });
    sdTooltipPosition = input('bottom', ...(ngDevMode ? [{ debugName: "sdTooltipPosition" }] : /* istanbul ignore next */ []));
    sdTooltipDelay = input(100, ...(ngDevMode ? [{ debugName: "sdTooltipDelay" }] : /* istanbul ignore next */ []));
    sdTooltipColor = input('#616161', ...(ngDevMode ? [{ debugName: "sdTooltipColor" }] : /* istanbul ignore next */ []));
    static activeTooltip = null;
    elementRef = inject(ElementRef);
    overlay = inject(Overlay);
    viewContainerRef = inject(ViewContainerRef);
    destroyRef = inject(DestroyRef);
    overlayRef = null;
    tooltipComponentRef = null;
    tooltipInstance = null;
    showTimeout;
    hideTimeout;
    constructor() {
        this.destroyRef.onDestroy(() => {
            this.#cleanup();
        });
    }
    onMouseEnter() {
        if (_a.activeTooltip && _a.activeTooltip !== this) {
            _a.activeTooltip.forceHide();
        }
        _a.activeTooltip = this;
        this.#clearTimeouts();
        this.showTimeout = setTimeout(() => {
            this.#show();
        }, this.sdTooltipDelay());
    }
    onMouseLeave() {
        this.#clearTimeouts();
        this.hideTimeout = setTimeout(() => {
            this.#hide();
        }, 300);
    }
    forceHide = () => {
        this.#clearTimeouts();
        this.#hide();
    };
    #show = () => {
        const currentContent = this.content();
        if (!currentContent)
            return;
        if (!this.overlayRef) {
            this.#createOverlay();
        }
        if (this.overlayRef && !this.overlayRef.hasAttached()) {
            const portal = new ComponentPortal(SdTooltipComponent, this.viewContainerRef);
            this.tooltipComponentRef = this.overlayRef.attach(portal);
            this.tooltipInstance = this.tooltipComponentRef.instance;
            this.#setupTooltipInstance();
        }
        if (this.tooltipComponentRef && this.tooltipInstance) {
            this.tooltipComponentRef.setInput('content', currentContent);
            this.tooltipComponentRef.setInput('color', this.sdTooltipColor());
            this.tooltipInstance.triggerChangeDetection();
        }
    };
    #hide = () => {
        if (this.tooltipInstance && this.overlayRef?.hasAttached()) {
            this.overlayRef.detach();
            this.tooltipInstance = null;
            this.tooltipComponentRef = null;
        }
    };
    #createOverlay = () => {
        const positionStrategy = this.overlay
            .position()
            .flexibleConnectedTo(this.elementRef)
            .withPositions(this.#getPositions())
            .withViewportMargin(8)
            .withPush(false);
        this.overlayRef = this.overlay.create({
            positionStrategy,
            scrollStrategy: this.overlay.scrollStrategies.close(),
            panelClass: 'c-sd-tooltip-panel',
        });
    };
    #setupTooltipInstance = () => {
        if (!this.tooltipInstance)
            return;
        this.tooltipInstance.onMouseEnterCb = () => {
            clearTimeout(this.hideTimeout);
        };
        this.tooltipInstance.onMouseLeaveCb = () => {
            this.hideTimeout = setTimeout(() => {
                this.#hide();
            }, 200);
        };
    };
    #clearTimeouts = () => {
        clearTimeout(this.showTimeout);
        clearTimeout(this.hideTimeout);
    };
    #cleanup = () => {
        this.#clearTimeouts();
        if (_a.activeTooltip === this) {
            _a.activeTooltip = null;
        }
        if (this.overlayRef) {
            this.overlayRef.dispose();
            this.overlayRef = null;
        }
        // Xóa mọi tham chiếu
        this.tooltipInstance = null;
        this.tooltipComponentRef = null;
    };
    #getPositions = () => {
        const offset = 8;
        const topPos = { originX: 'center', originY: 'top', overlayX: 'center', overlayY: 'bottom', offsetY: -offset };
        const bottomPos = {
            originX: 'center',
            originY: 'bottom',
            overlayX: 'center',
            overlayY: 'top',
            offsetY: offset,
        };
        const leftPos = { originX: 'start', originY: 'center', overlayX: 'end', overlayY: 'center', offsetX: -offset };
        const rightPos = { originX: 'end', originY: 'center', overlayX: 'start', overlayY: 'center', offsetX: offset };
        switch (this.sdTooltipPosition()) {
            case 'top':
                return [topPos, bottomPos, rightPos, leftPos];
            case 'bottom':
                return [bottomPos, topPos, rightPos, leftPos];
            case 'left':
                return [leftPos, rightPos, topPos, bottomPos];
            case 'right':
                return [rightPos, leftPos, topPos, bottomPos];
            default:
                return [bottomPos, topPos];
        }
    };
    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SdTooltipDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.2.17", type: SdTooltipDirective, isStandalone: true, selector: "[sdTooltip]", inputs: { content: { classPropertyName: "content", publicName: "sdTooltip", isSignal: true, isRequired: true, transformFunction: null }, sdTooltipPosition: { classPropertyName: "sdTooltipPosition", publicName: "sdTooltipPosition", isSignal: true, isRequired: false, transformFunction: null }, sdTooltipDelay: { classPropertyName: "sdTooltipDelay", publicName: "sdTooltipDelay", isSignal: true, isRequired: false, transformFunction: null }, sdTooltipColor: { classPropertyName: "sdTooltipColor", publicName: "sdTooltipColor", isSignal: true, isRequired: false, transformFunction: null } }, host: { listeners: { "mouseenter": "onMouseEnter()", "mouseleave": "onMouseLeave()" } }, ngImport: i0 });
}
_a = SdTooltipDirective;
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.17", ngImport: i0, type: SdTooltipDirective, decorators: [{
            type: Directive,
            args: [{
                    selector: '[sdTooltip]',
                    standalone: true,
                }]
        }], ctorParameters: () => [], propDecorators: { content: [{ type: i0.Input, args: [{ isSignal: true, alias: "sdTooltip", required: true }] }], sdTooltipPosition: [{ type: i0.Input, args: [{ isSignal: true, alias: "sdTooltipPosition", required: false }] }], sdTooltipDelay: [{ type: i0.Input, args: [{ isSignal: true, alias: "sdTooltipDelay", required: false }] }], sdTooltipColor: [{ type: i0.Input, args: [{ isSignal: true, alias: "sdTooltipColor", required: false }] }], onMouseEnter: [{
                type: HostListener,
                args: ['mouseenter']
            }], onMouseLeave: [{
                type: HostListener,
                args: ['mouseleave']
            }] } });

/**
 * Generated bundle index. Do not edit.
 */

export { SdDesktopDirective, SdHoverCopyDirective, SdHrefDirective, SdMobileDirective, SdScrollDirective, SdTooltipDirective };
//# sourceMappingURL=sdcorejs-angular-directives.mjs.map
