import * as _angular_core from '@angular/core';
import { InjectionToken, OnInit, OnChanges, OnDestroy } from '@angular/core';
import * as _siemens_element_translate_ng_translate from '@siemens/element-translate-ng/translate';
import { TranslatableString } from '@siemens/element-translate-ng/translate';
import * as rxjs from 'rxjs';
import { BehaviorSubject } from 'rxjs';

declare class SiLoadingButtonComponent {
    /**
     * Whether the button is disabled.
     * @defaultValue false
     */
    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * Whether the loading state should be displayed.
     * @defaultValue false
     */
    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * Type of the button.
     * @defaultValue 'button'
     **/
    readonly type: _angular_core.InputSignal<"button" | "submit" | "reset">;
    /** aria-label for the button */
    readonly ariaLabel: _angular_core.InputSignal<TranslatableString | undefined>;
    /** aria-labelledby for the button */
    readonly ariaLabelledBy: _angular_core.InputSignal<string | undefined>;
    /**
     * CSS class for the button.
     * @defaultValue ''
     */
    readonly buttonClass: _angular_core.InputSignal<string>;
    protected handleClick(event: Event): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiLoadingButtonComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SiLoadingButtonComponent, "si-loading-button", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "ariaLabelledBy": { "alias": "ariaLabelledBy"; "required": false; "isSignal": true; }; "buttonClass": { "alias": "buttonClass"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare const LOADING_SPINNER_BLOCKING: InjectionToken<boolean>;
declare const LOADING_SPINNER_OVERLAY: InjectionToken<boolean>;
declare class SiLoadingSpinnerComponent {
    /**
     * @defaultValue
     * ```
     * inject(LOADING_SPINNER_BLOCKING, { optional: true })
     * ```
     */
    readonly isBlockingSpinner: _angular_core.InputSignal<boolean | null>;
    /**
     * @defaultValue
     * ```
     * inject(LOADING_SPINNER_OVERLAY, { optional: true })
     * ```
     */
    readonly isSpinnerOverlay: _angular_core.InputSignal<boolean | null>;
    /**
     * Needed for a11y
     *
     * @defaultValue
     * ```
     * t(() => $localize`:@@SI_LOADING_SPINNER.LABEL:Loading`)
     * ```
     */
    readonly ariaLabel: _angular_core.InputSignal<_siemens_element_translate_ng_translate.TranslatableString>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiLoadingSpinnerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SiLoadingSpinnerComponent, "si-loading-spinner", never, { "isBlockingSpinner": { "alias": "isBlockingSpinner"; "required": false; "isSignal": true; }; "isSpinnerOverlay": { "alias": "isSpinnerOverlay"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class SiLoadingSpinnerDirective implements OnInit, OnChanges, OnDestroy {
    /**
     * Displays the loading spinner when the value is either true or non-zero.
     */
    readonly siLoading: _angular_core.InputSignal<number | boolean>;
    /**
     * Displays semi-transparent backdrop for the spinner, default is false.
     *
     * @defaultValue false
     */
    readonly blocking: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * Specifies if the spinner should be displayed after a delay, default is true.
     *
     * @defaultValue true
     */
    readonly initialDelay: _angular_core.InputSignalWithTransform<boolean, unknown>;
    private el;
    private readonly viewRef;
    private cdRef;
    private sub?;
    private progressSubject;
    private off$;
    private on$;
    private readonly initialWaitTime;
    private minSpinTime;
    private portalOutlet?;
    private readonly compPortal;
    protected readonly spinner$: rxjs.Observable<boolean>;
    private createPortal;
    ngOnInit(): void;
    ngOnChanges(): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiLoadingSpinnerDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SiLoadingSpinnerDirective, "[siLoading]", never, { "siLoading": { "alias": "siLoading"; "required": true; "isSignal": true; }; "blocking": { "alias": "blocking"; "required": false; "isSignal": true; }; "initialDelay": { "alias": "initialDelay"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class SiLoadingService {
    /**
     * Counts the number of loads active, is `0` when all loading is finished (or hasn't started).
     */
    readonly counter: BehaviorSubject<number>;
    /**
     * Start the loading.
     */
    startLoad(): void;
    /**
     * Stop the loading.
     */
    stopLoad(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiLoadingService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SiLoadingService>;
}

declare class SiLoadingSpinnerModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiLoadingSpinnerModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<SiLoadingSpinnerModule, never, [typeof SiLoadingSpinnerComponent, typeof SiLoadingSpinnerDirective], [typeof SiLoadingSpinnerComponent, typeof SiLoadingSpinnerDirective]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<SiLoadingSpinnerModule>;
}

export { LOADING_SPINNER_BLOCKING, LOADING_SPINNER_OVERLAY, SiLoadingButtonComponent, SiLoadingService, SiLoadingSpinnerComponent, SiLoadingSpinnerDirective, SiLoadingSpinnerModule };
