turbogui-angular 11.0.2 → 12.0.0

package/index.d.ts

@@ -1,6 +1,6 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="turbogui-angular" />
-export * from './public_api';
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="turbogui-angular" />
+export * from './public_api';
 //# sourceMappingURL=turbogui-angular.d.ts.map

package/main/controller/browser.service.d.ts

@@ -1,30 +1,30 @@
-import { BrowserManager } from 'turbocommons-ts';
-import { Location, PopStateEvent } from '@angular/common';
-import * as i0 from "@angular/core";
-/**
- * An abstraction of the browser entity an all its related operations and properties
- */
-export declare class BrowserService extends BrowserManager {
-    private readonly location;
-    constructor(location: Location);
-    /**
-     * Modify the current browser URI without reloading the current page document
-     *
-     * @param path The uri value we want to set
-     * @param query The query url parameters part we want to specify if any
-     *
-     * @returns void
-     */
-    setURI(path: string, query?: string | undefined): void;
-    /**
-     * Obtain a subscription to get notified on any changes at the browser url
-     *
-     * @param onNext A method to be executed every time the url changes on the browser. The url will be available inside the value parameter
-     *
-     * @returns Subscribed events. Make sure to unsubscribe when not needed
-     */
-    subscribeToUrlChange(onNext: (value: PopStateEvent) => void): import("rxjs").SubscriptionLike;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BrowserService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<BrowserService>;
-}
+import { BrowserManager } from 'turbocommons-ts';
+import { Location, PopStateEvent } from '@angular/common';
+import * as i0 from "@angular/core";
+/**
+ * An abstraction of the browser entity an all its related operations and properties
+ */
+export declare class BrowserService extends BrowserManager {
+    private readonly location;
+    constructor(location: Location);
+    /**
+     * Modify the current browser URI without reloading the current page document
+     *
+     * @param path The uri value we want to set
+     * @param query The query url parameters part we want to specify if any
+     *
+     * @returns void
+     */
+    setURI(path: string, query?: string | undefined): void;
+    /**
+     * Obtain a subscription to get notified on any changes at the browser url
+     *
+     * @param onNext A method to be executed every time the url changes on the browser. The url will be available inside the value parameter
+     *
+     * @returns Subscribed events. Make sure to unsubscribe when not needed
+     */
+    subscribeToUrlChange(onNext: (value: PopStateEvent) => void): import("rxjs").SubscriptionLike;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BrowserService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BrowserService>;
+}
 //# sourceMappingURL=browser.service.d.ts.map

package/main/controller/dialog.service.d.ts

@@ -1,185 +1,185 @@
-import { Type, ComponentFactoryResolver, Injector, ApplicationRef, RendererFactory2 } from '@angular/core';
-import { MatDialog } from '@angular/material/dialog';
-import { MatSnackBar, MatSnackBarConfig } from '@angular/material/snack-bar';
-import { BusyStateBaseComponent } from '../view/components/busy-state-base/busy-state-base.component';
-import { DialogOptionsBaseComponent } from '../view/components/dialog-options-base/dialog-options-base.component';
-import * as i0 from "@angular/core";
-/**
- * Manages the application modal and non modal floating elements
- */
-export declare class DialogService {
-    private readonly matSnackBar;
-    private readonly matDialog;
-    private readonly injector;
-    private readonly applicationRef;
-    private readonly componentFactoryResolver;
-    /**
-     * Used to modify the busy state component that is shown by default by the addModalBusyState() method.
-     *
-     * @see this.addModalBusyState()
-     */
-    customBusyStateComponentClass: Type<BusyStateBaseComponent>;
-    /**
-     * Check public getter for docs
-     */
-    private _isEnabled;
-    /**
-     * Tells if the main application is currently showing a busy state that blocks all user interaction
-     */
-    private _isShowingBusyState;
-    /**
-     * A reference to the modal busy state component that is initialized only the first time it is called.
-     *
-     * (To append the busy state dynamically, we use the Portal concept from the angular material library)
-     */
-    private _componentPortal;
-    /**
-     * A reference to the modal busy state container where the component will be added
-     */
-    private _modalBusyStateHost;
-    /**
-     * Tells if the manager is currently showing a snackbar element or not
-     */
-    private _isShowingSnackBar;
-    /**
-     * Contains a list of the dialogs that are currently visible to the user.
-     * Each item in this list is a hash that is computed when dialog is created to uniquely identify it.
-     *
-     * Empty list means no dialogs are currently visible
-     */
-    private _activeDialogs;
-    /**
-     * Contains a list with all the MatDialog instances that are currently visible to the user.
-     * The list uses the same order as the list of _activeDialogs hash values
-     */
-    private _activeDialogInstances;
-    /**
-     * Used to store the initialized Renderer 2 instance that is used by this class
-     */
-    private readonly _renderer;
-    /**
-     * Method that is used to delete the window beforeunload event listener once not used anymore
-     */
-    private _windowBeforeUnloadUnListen;
-    /**
-     * Method that is used to delete the document keydown event listener once not used anymore
-     */
-    private _documentKeydownUnlisten;
-    /**
-     * Method that is used to delete the document mousedown event listener once not used anymore
-     */
-    private _documentMousedownUnlisten;
-    /**
-     * Method that is used to delete the document pointerdown event listener once not used anymore
-     */
-    private _documentPointerdownUnlisten;
-    constructor(rendererFactory: RendererFactory2, matSnackBar: MatSnackBar, matDialog: MatDialog, injector: Injector, applicationRef: ApplicationRef, componentFactoryResolver: ComponentFactoryResolver);
-    /**
-     * Tells if this dialog service is enabled or not. If dialog service is disabled, none of it's features will work
-     * This is used to block all dialog features normally when shutting down the application
-     *
-     * Use with caution. When this is set to false, dialog service stops working.
-     */
-    set isEnabled(v: boolean);
-    /**
-     * Enables a warning that will be shown to the user when he/she tries to close the application.
-     * This warning will prompt the user to continue with the exit process or cancel it.
-     * The specific texts of this message are a generic ones and cannot be changed.
-     *
-     * IMPORTANT: This method must be called after the main application has been initialized in order to work,
-     * otherwise it will do nothing.
-     */
-    addCloseApplicationWarning(): void;
-    /**
-     * Remove the close application warning message if previously assigned
-     */
-    removeCloseApplicationWarning(): void;
-    /**
-     * Change the application visual appearance so the user perceives that the application is
-     * currently busy. While modal busy state is enabled, no user input is possible neither via
-     * keyboard, mouse or touch. Use this state when performing server requests or operations that
-     * must block the user interaction with the application.
-     *
-     * Note: We can modify the busy state component that is shown by this method. To do it, we must
-     * set this.customBusyStateComponentClass property with our own custom busy state component class. (We can do it at
-     * our main application component constructor for example). Our custom component must extend the
-     * BusyStateBaseComponent one to add its own visual appearance.
-     *
-     * @see this.customBusyStateComponentClass
-     */
-    addModalBusyState(): void;
-    /**
-     * Tells if the application is currently locked in a modal busy state (caused by an addModalBusyState() call)
-     */
-    get isShowingBusyState(): boolean;
-    /**
-     * Remove the application busy state and restore it back to normal user interaction
-     */
-    removeModalBusyState(): void;
-    /**
-     * TODO - adapt from TS version
-     */
-    addToolTip(): void;
-    /**
-     * Show a non modal snackbar notification to the user (Only one snack-bar can ever be opened at the same time).
-     *
-     * Snackbars inform users of a process that an app has performed or will perform. They appear temporarily, towards the bottom or top of the screen.
-     * They shouldn’t interrupt the user experience, and they don’t require user input to disappear.
-     *
-     * @param config A MatSnackBarConfig instance with the customizations we want for this snackbar
-     * @param message The message to show on the snackbar
-     * @param action If not empty, the text to place on the snackbar confirmation button
-     * @param actionCallback A method to execute once the user clicks into the action button.
-     *
-     * @return void
-     */
-    addSnackBar(config: MatSnackBarConfig, message: string, action?: string, actionCallback?: (() => void) | null): void;
-    /**
-     * Tells if the application is currently showing a snackbar or not
-     */
-    get isShowingSnackBar(): boolean;
-    /**
-     * Force the removal of the snack bar dialog if it exists.
-     *
-     * If no snackbar is currently visible, this method will do nothing
-     */
-    removeSnackBar(): void;
-    /**
-     * Show a dialog with one or more options that can be used to close it. We can use any of the predefined dialog types that are bundled with
-     * this library or extend DialogOptionsBaseComponent to create our own custom ones.
-     *
-     * @param width Specify the css value for the maximum width the dialog will have. As the dialog is responsive, the value will be automatically
-              reduced if the available screen is not enough, and will reach the desired value otherwise. Note that height will be adapted to the contents
-              of the dialog and cannot be specified here. We can set a pixels, % or any other css accepted value. For example: '400px', '50%', etc.
-     * @param texts A list with strings containing the dialog texts, sorted by importance. When dialog has a title, this should
-     *        be placed first, subtitle second and so (Each dialog may accept different kind of texts).
-     * @param options A list of strings that will be used as button captions for each one of the accepted dialog options
-     * @param dialogComponentClass A class for a component that extends DialogOptionsBaseComponent, which will be the
-     *        dialog visual element that is shown to the user.
-     * @param callback A function that will be called after the dialog is closed and will receive an object with the numeric index and value for
-     *        the option that's been selected by the user.
-     * @param modal True (default) if selecting an option is mandatory to close the dialog, false if the dialog can be closed
-     *        by the user by clicking outside it
-     */
-    addDialog(width: string, texts: string[], options: string[], dialogComponentClass: Type<DialogOptionsBaseComponent>, callback?: null | ((selectedOption: {
-        index: number;
-        value: string;
-    }) => void), modal?: boolean): void;
-    /**
-     * Force the removal of all the dialogs that are currently visible.
-     *
-     * If no dialogs are currently visible, this method will do nothing
-     */
-    removeAllDialogs(): void;
-    /**
-     * Block all the user interactions with the application (keyboard, touch, mouse, ...)
-     */
-    private _disableUserInteraction;
-    /**
-     * Restore the user interactions that were previously disabled with _disableUserInteraction method
-     */
-    private _enableUserInteraction;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DialogService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<DialogService>;
-}
+import { Type, ComponentFactoryResolver, Injector, ApplicationRef, RendererFactory2 } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { MatSnackBar, MatSnackBarConfig } from '@angular/material/snack-bar';
+import { BusyStateBaseComponent } from '../view/components/busy-state-base/busy-state-base.component';
+import { DialogOptionsBaseComponent } from '../view/components/dialog-options-base/dialog-options-base.component';
+import * as i0 from "@angular/core";
+/**
+ * Manages the application modal and non modal floating elements
+ */
+export declare class DialogService {
+    private readonly matSnackBar;
+    private readonly matDialog;
+    private readonly injector;
+    private readonly applicationRef;
+    private readonly componentFactoryResolver;
+    /**
+     * Used to modify the busy state component that is shown by default by the addModalBusyState() method.
+     *
+     * @see this.addModalBusyState()
+     */
+    customBusyStateComponentClass: Type<BusyStateBaseComponent>;
+    /**
+     * Check public getter for docs
+     */
+    private _isEnabled;
+    /**
+     * Tells if the main application is currently showing a busy state that blocks all user interaction
+     */
+    private _isShowingBusyState;
+    /**
+     * A reference to the modal busy state component that is initialized only the first time it is called.
+     *
+     * (To append the busy state dynamically, we use the Portal concept from the angular material library)
+     */
+    private _componentPortal;
+    /**
+     * A reference to the modal busy state container where the component will be added
+     */
+    private _modalBusyStateHost;
+    /**
+     * Tells if the manager is currently showing a snackbar element or not
+     */
+    private _isShowingSnackBar;
+    /**
+     * Contains a list of the dialogs that are currently visible to the user.
+     * Each item in this list is a hash that is computed when dialog is created to uniquely identify it.
+     *
+     * Empty list means no dialogs are currently visible
+     */
+    private _activeDialogs;
+    /**
+     * Contains a list with all the MatDialog instances that are currently visible to the user.
+     * The list uses the same order as the list of _activeDialogs hash values
+     */
+    private _activeDialogInstances;
+    /**
+     * Used to store the initialized Renderer 2 instance that is used by this class
+     */
+    private readonly _renderer;
+    /**
+     * Method that is used to delete the window beforeunload event listener once not used anymore
+     */
+    private _windowBeforeUnloadUnListen;
+    /**
+     * Method that is used to delete the document keydown event listener once not used anymore
+     */
+    private _documentKeydownUnlisten;
+    /**
+     * Method that is used to delete the document mousedown event listener once not used anymore
+     */
+    private _documentMousedownUnlisten;
+    /**
+     * Method that is used to delete the document pointerdown event listener once not used anymore
+     */
+    private _documentPointerdownUnlisten;
+    constructor(rendererFactory: RendererFactory2, matSnackBar: MatSnackBar, matDialog: MatDialog, injector: Injector, applicationRef: ApplicationRef, componentFactoryResolver: ComponentFactoryResolver);
+    /**
+     * Tells if this dialog service is enabled or not. If dialog service is disabled, none of it's features will work
+     * This is used to block all dialog features normally when shutting down the application
+     *
+     * Use with caution. When this is set to false, dialog service stops working.
+     */
+    set isEnabled(v: boolean);
+    /**
+     * Enables a warning that will be shown to the user when he/she tries to close the application.
+     * This warning will prompt the user to continue with the exit process or cancel it.
+     * The specific texts of this message are a generic ones and cannot be changed.
+     *
+     * IMPORTANT: This method must be called after the main application has been initialized in order to work,
+     * otherwise it will do nothing.
+     */
+    addCloseApplicationWarning(): void;
+    /**
+     * Remove the close application warning message if previously assigned
+     */
+    removeCloseApplicationWarning(): void;
+    /**
+     * Change the application visual appearance so the user perceives that the application is
+     * currently busy. While modal busy state is enabled, no user input is possible neither via
+     * keyboard, mouse or touch. Use this state when performing server requests or operations that
+     * must block the user interaction with the application.
+     *
+     * Note: We can modify the busy state component that is shown by this method. To do it, we must
+     * set this.customBusyStateComponentClass property with our own custom busy state component class. (We can do it at
+     * our main application component constructor for example). Our custom component must extend the
+     * BusyStateBaseComponent one to add its own visual appearance.
+     *
+     * @see this.customBusyStateComponentClass
+     */
+    addModalBusyState(): void;
+    /**
+     * Tells if the application is currently locked in a modal busy state (caused by an addModalBusyState() call)
+     */
+    get isShowingBusyState(): boolean;
+    /**
+     * Remove the application busy state and restore it back to normal user interaction
+     */
+    removeModalBusyState(): void;
+    /**
+     * TODO - adapt from TS version
+     */
+    addToolTip(): void;
+    /**
+     * Show a non modal snackbar notification to the user (Only one snack-bar can ever be opened at the same time).
+     *
+     * Snackbars inform users of a process that an app has performed or will perform. They appear temporarily, towards the bottom or top of the screen.
+     * They shouldn’t interrupt the user experience, and they don’t require user input to disappear.
+     *
+     * @param config A MatSnackBarConfig instance with the customizations we want for this snackbar
+     * @param message The message to show on the snackbar
+     * @param action If not empty, the text to place on the snackbar confirmation button
+     * @param actionCallback A method to execute once the user clicks into the action button.
+     *
+     * @return void
+     */
+    addSnackBar(config: MatSnackBarConfig, message: string, action?: string, actionCallback?: (() => void) | null): void;
+    /**
+     * Tells if the application is currently showing a snackbar or not
+     */
+    get isShowingSnackBar(): boolean;
+    /**
+     * Force the removal of the snack bar dialog if it exists.
+     *
+     * If no snackbar is currently visible, this method will do nothing
+     */
+    removeSnackBar(): void;
+    /**
+     * Show a dialog with one or more options that can be used to close it. We can use any of the predefined dialog types that are bundled with
+     * this library or extend DialogOptionsBaseComponent to create our own custom ones.
+     *
+     * @param width Specify the css value for the maximum width the dialog will have. As the dialog is responsive, the value will be automatically
+              reduced if the available screen is not enough, and will reach the desired value otherwise. Note that height will be adapted to the contents
+              of the dialog and cannot be specified here. We can set a pixels, % or any other css accepted value. For example: '400px', '50%', etc.
+     * @param texts A list with strings containing the dialog texts, sorted by importance. When dialog has a title, this should
+     *        be placed first, subtitle second and so (Each dialog may accept different kind of texts).
+     * @param options A list of strings that will be used as button captions for each one of the accepted dialog options
+     * @param dialogComponentClass A class for a component that extends DialogOptionsBaseComponent, which will be the
+     *        dialog visual element that is shown to the user.
+     * @param callback A function that will be called after the dialog is closed and will receive an object with the numeric index and value for
+     *        the option that's been selected by the user.
+     * @param modal True (default) if selecting an option is mandatory to close the dialog, false if the dialog can be closed
+     *        by the user by clicking outside it
+     */
+    addDialog(width: string, texts: string[], options: string[], dialogComponentClass: Type<DialogOptionsBaseComponent>, callback?: null | ((selectedOption: {
+        index: number;
+        value: string;
+    }) => void), modal?: boolean): void;
+    /**
+     * Force the removal of all the dialogs that are currently visible.
+     *
+     * If no dialogs are currently visible, this method will do nothing
+     */
+    removeAllDialogs(): void;
+    /**
+     * Block all the user interactions with the application (keyboard, touch, mouse, ...)
+     */
+    private _disableUserInteraction;
+    /**
+     * Restore the user interactions that were previously disabled with _disableUserInteraction method
+     */
+    private _enableUserInteraction;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DialogService>;
+}
 //# sourceMappingURL=dialog.service.d.ts.map

package/main/controller/globalerror.service.d.ts

@@ -1,55 +1,55 @@
-/**
- * TurboGUI is A library that helps with the most common and generic UI elements and functionalities
- *
- * Website : -> http://www.turbogui.org
- * License : -> Licensed under the Apache License, Version 2.0. You may not use this file except in compliance with the License.
- * License Url : -> http://www.apache.org/licenses/LICENSE-2.0
- * CopyRight : -> Copyright 2018 Edertone Advanded Solutions. https://www.edertone.com
- */
-import { ErrorHandler } from '@angular/core';
-import * as i0 from "@angular/core";
-/**
- * Captures all the application exceptions and performs any required action.
- * It also contains multiple general error management features.
- *
- * To define this class as your application error handler, you must add the following to your
- * main app module providers:
- *      {
- *          provide: ErrorHandler,
- *          useClass: GlobalErrorService
- *      },
- *      GlobalErrorService
- *
- * You cannot access the error handler at runtime. If you need to modify any of the behaviours
- * or implement your custom ones, you must extend this class and set your new one as the error
- * handler provider.
- */
-export declare class GlobalErrorService implements ErrorHandler {
-    /**
-     * Enables or disables the error notification to user via an alert box
-     * Extend this class and override this value on your custom error handle to change it
-     */
-    private readonly showExceptionsToUser;
-    /**
-     * Enables or disables the error notification to user via an alert box
-     * Extend this class and override this value on your custom error handle to change it
-     */
-    private readonly showExceptionsOnConsole;
-    /**
-     * Defines the text that will be used for the alert that is shown to the user when an exception happens
-     * and showExceptionsToUser is true
-     * Extend this class and override this value on your custom error handle to change it
-     */
-    private readonly errorAlertMessage;
-    /**
-     * Show an alert with the received error detail and also log it to the js console.
-     *
-     * Angular expects at least this method to be implemented on any class that is used as a global exception handler.
-     *
-     * @param error An error instance
-     */
-    handleError(error: any): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<GlobalErrorService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<GlobalErrorService>;
-}
+/**
+ * TurboGUI is A library that helps with the most common and generic UI elements and functionalities
+ *
+ * Website : -> http://www.turbogui.org
+ * License : -> Licensed under the Apache License, Version 2.0. You may not use this file except in compliance with the License.
+ * License Url : -> http://www.apache.org/licenses/LICENSE-2.0
+ * CopyRight : -> Copyright 2018 Edertone Advanded Solutions. https://www.edertone.com
+ */
+import { ErrorHandler } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Captures all the application exceptions and performs any required action.
+ * It also contains multiple general error management features.
+ *
+ * To define this class as your application error handler, you must add the following to your
+ * main app module providers:
+ *      {
+ *          provide: ErrorHandler,
+ *          useClass: GlobalErrorService
+ *      },
+ *      GlobalErrorService
+ *
+ * You cannot access the error handler at runtime. If you need to modify any of the behaviours
+ * or implement your custom ones, you must extend this class and set your new one as the error
+ * handler provider.
+ */
+export declare class GlobalErrorService implements ErrorHandler {
+    /**
+     * Enables or disables the error notification to user via an alert box
+     * Extend this class and override this value on your custom error handle to change it
+     */
+    private readonly showExceptionsToUser;
+    /**
+     * Enables or disables the error notification to user via an alert box
+     * Extend this class and override this value on your custom error handle to change it
+     */
+    private readonly showExceptionsOnConsole;
+    /**
+     * Defines the text that will be used for the alert that is shown to the user when an exception happens
+     * and showExceptionsToUser is true
+     * Extend this class and override this value on your custom error handle to change it
+     */
+    private readonly errorAlertMessage;
+    /**
+     * Show an alert with the received error detail and also log it to the js console.
+     *
+     * Angular expects at least this method to be implemented on any class that is used as a global exception handler.
+     *
+     * @param error An error instance
+     */
+    handleError(error: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GlobalErrorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GlobalErrorService>;
+}
 //# sourceMappingURL=globalerror.service.d.ts.map

package/main/controller/http.service.d.ts

@@ -1,38 +1,38 @@
-import { HTTPManager, HTTPManagerBaseRequest } from 'turbocommons-ts';
-import { DialogService } from './dialog.service';
-import * as i0 from "@angular/core";
-/**
- * Manages application http communications
- */
-export declare class HTTPService extends HTTPManager {
-    dialogService: DialogService;
-    /**
-     * execute() method option that tells the service to avoid blocking the user interface with a modal busy state while the requests that are
-     * launched by the execute method are running.
-     */
-    static readonly NO_MODAL_BUSY_STATE = "NO_MODAL_BUSY_STATE";
-    /**
-     * execute() method option that tells the service to skip showing an error dialog when a request fails. We normally use this to handle the
-     * errors by ourselves or if we want to hide the error dialog for a specific request.
-     */
-    static readonly DISABLE_ERROR_HANDLING = "DISABLE_ERROR_HANDLING";
-    constructor(dialogService: DialogService);
-    /**
-     * The same method as HTTPManager.execute but with the ability to enable several options which are specific to this service:
-     *
-     * - HTTPService.NO_MODAL_BUSY_STATE To prevent the default behaviour of locking the UI while the request is running
-     * - HTTPService.DISABLE_ERROR_HANDLING To prevent the default behaviour of showing a detailed error dialog when a request fails
-     *
-     * @see HTTPManager.execute()
-     */
-    execute(requests: string | string[] | HTTPManagerBaseRequest | HTTPManagerBaseRequest[], finishedCallback?: ((results: {
-        url: string;
-        response: any;
-        isError: boolean;
-        errorMsg: string;
-        code: number;
-    }[], anyError: boolean) => void) | null, progressCallback?: null | ((completedUrl: string, totalRequests: number) => void), options?: (typeof HTTPService.NO_MODAL_BUSY_STATE | typeof HTTPService.DISABLE_ERROR_HANDLING)[]): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<HTTPService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<HTTPService>;
-}
+import { HTTPManager, HTTPManagerBaseRequest } from 'turbocommons-ts';
+import { DialogService } from './dialog.service';
+import * as i0 from "@angular/core";
+/**
+ * Manages application http communications
+ */
+export declare class HTTPService extends HTTPManager {
+    dialogService: DialogService;
+    /**
+     * execute() method option that tells the service to avoid blocking the user interface with a modal busy state while the requests that are
+     * launched by the execute method are running.
+     */
+    static readonly NO_MODAL_BUSY_STATE = "NO_MODAL_BUSY_STATE";
+    /**
+     * execute() method option that tells the service to skip showing an error dialog when a request fails. We normally use this to handle the
+     * errors by ourselves or if we want to hide the error dialog for a specific request.
+     */
+    static readonly DISABLE_ERROR_HANDLING = "DISABLE_ERROR_HANDLING";
+    constructor(dialogService: DialogService);
+    /**
+     * The same method as HTTPManager.execute but with the ability to enable several options which are specific to this service:
+     *
+     * - HTTPService.NO_MODAL_BUSY_STATE To prevent the default behaviour of locking the UI while the request is running
+     * - HTTPService.DISABLE_ERROR_HANDLING To prevent the default behaviour of showing a detailed error dialog when a request fails
+     *
+     * @see HTTPManager.execute()
+     */
+    execute(requests: string | string[] | HTTPManagerBaseRequest | HTTPManagerBaseRequest[], finishedCallback?: ((results: {
+        url: string;
+        response: any;
+        isError: boolean;
+        errorMsg: string;
+        code: number;
+    }[], anyError: boolean) => void) | null, progressCallback?: null | ((completedUrl: string, totalRequests: number) => void), options?: (typeof HTTPService.NO_MODAL_BUSY_STATE | typeof HTTPService.DISABLE_ERROR_HANDLING)[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HTTPService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HTTPService>;
+}
 //# sourceMappingURL=http.service.d.ts.map