import { Observable } from 'rxjs';
import * as _angular_core from '@angular/core';
import { OnInit, OnDestroy } from '@angular/core';

interface ElementDimensions {
    width: number;
    height: number;
}
/**
 * A service wrapping `ResizeObserver`. This is a service for those reasons:
 * - only one `ResizeObserver` should be used for performance reason.
 * - For Angular change detection to work, explicit `ngZone` calls are necessary
 * - Observable stream
 */
declare class ResizeObserverService {
    private listeners;
    private resizeObserver?;
    private timerQueue;
    private zone;
    constructor();
    /**
     * Observe the size of an element. Returns an observable with the changes.
     * @param element - The element to observe
     * @param throttle - Throttle time in ms. Will emit this time after the resize
     * @param emitInitial - Emit the initial size after subscribe?
     * @param emitImmediate - Emit an event immediately after the size changes. Useful e.g. for visibility checks.
     */
    observe(element: Element, throttle: number, emitInitial?: boolean, emitImmediate?: boolean): Observable<ElementDimensions>;
    private subscriberAdded;
    private subscriberRemoved;
    private handleElement;
    private handleResizeSubscriber;
    private emitSize;
    private schedule;
    private unschedule;
    private processQueue;
    /**
     * check size on all observed elements. Only use in testing!
     * @deprecated Will be removed in major version 50! For testing purposes use the resize observer mock:
     *
     * ```ts
     * beforeEach(() => mockResizeObserver());
     * afterEach(() => restoreResizeObserver());
     * it('should trigger resize', () => {
     *   // For all observed elements
     *   MockResizeObserver.triggerResize({});
     *   // For specific HTML element
     *   MockResizeObserver.triggerResize({ target: myElement });
     * });
     * ```
  
     */
    _checkAll(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ResizeObserverService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ResizeObserverService>;
}

/**
 * Directive to emit events on element size change. Use like this:
 *   `<div (siResizeObserver)="handleResize($event)">`
 * When the size of the element changes, an event in the format
 *   `{ width: number, height: number }`
 * will be emitted. Also an initial event will be emitted on init.
 *
 * By default, events are throttled and to an event every 100ms. To change
 * this, add `[resizeThrottle]="200"` on the same element. Input in milliseconds.
 */
declare class SiResizeObserverDirective implements OnInit, OnDestroy {
    /** @defaultValue 100 */
    readonly resizeThrottle: _angular_core.InputSignal<number>;
    /** @defaultValue true */
    readonly emitInitial: _angular_core.InputSignalWithTransform<boolean, unknown>;
    readonly siResizeObserver: _angular_core.OutputEmitterRef<ElementDimensions>;
    private subs?;
    private element;
    private service;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiResizeObserverDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SiResizeObserverDirective, "[siResizeObserver]", never, { "resizeThrottle": { "alias": "resizeThrottle"; "required": false; "isSignal": true; }; "emitInitial": { "alias": "emitInitial"; "required": false; "isSignal": true; }; }, { "siResizeObserver": "siResizeObserver"; }, never, never, true, never>;
}

interface Breakpoints {
    smMinimum: number;
    mdMinimum: number;
    lgMinimum: number;
    xlMinimum: number;
    xxlMinimum: number;
}
declare const BOOTSTRAP_BREAKPOINTS: Breakpoints;
/**
 * Directive to automatically set `si-container-*` classes so Bootstrap column classes work
 * in the context of the container instead of viewport size.
 */
declare class SiResponsiveContainerDirective implements OnInit, OnDestroy {
    /** @defaultValue false */
    readonly xs: _angular_core.WritableSignal<boolean>;
    /** @defaultValue false */
    readonly sm: _angular_core.WritableSignal<boolean>;
    /** @defaultValue false */
    readonly md: _angular_core.WritableSignal<boolean>;
    /** @defaultValue false */
    readonly lg: _angular_core.WritableSignal<boolean>;
    /** @defaultValue false */
    readonly xl: _angular_core.WritableSignal<boolean>;
    /** @defaultValue false */
    readonly xxl: _angular_core.WritableSignal<boolean>;
    /** @defaultValue 100 */
    readonly resizeThrottle: _angular_core.InputSignal<number>;
    readonly breakpoints: _angular_core.InputSignal<Breakpoints | undefined>;
    private subs?;
    private element;
    private service;
    ngOnInit(): void;
    ngOnDestroy(): void;
    private setResponsiveSize;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiResponsiveContainerDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SiResponsiveContainerDirective, "[siResponsiveContainer]", ["siResponsiveContainer"], { "resizeThrottle": { "alias": "resizeThrottle"; "required": false; "isSignal": true; }; "breakpoints": { "alias": "breakpoints"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class SiResizeObserverModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiResizeObserverModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<SiResizeObserverModule, never, [typeof SiResizeObserverDirective, typeof SiResponsiveContainerDirective], [typeof SiResizeObserverDirective, typeof SiResponsiveContainerDirective]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<SiResizeObserverModule>;
}

export { BOOTSTRAP_BREAKPOINTS, ResizeObserverService, SiResizeObserverDirective, SiResizeObserverModule, SiResponsiveContainerDirective };
export type { Breakpoints, ElementDimensions };
