/// <reference types="core" />
/// <reference types="core-dts" />
/// <reference types="angular" />
/// <reference types="jquery" />
/// <reference types="bootstrap" />
/// <reference types="jqueryui" />
/// <reference types="urijs" />
/// <reference types="angular-mocks" />
/// <reference types="angular-route" />
/// <reference types="angular-ui-bootstrap" />
declare namespace Integration {
    function configureAboutPage(aboutService: About.AboutService): void;
}
declare namespace ActiveMQ {
    const pluginName: string;
    const log: Logging.Logger;
    const jmxDomain: string;
    function retrieveQueueNames(workspace: Jmx.Workspace, ascend: boolean): string[];
    function retrieveTopicNames(workspace: Jmx.Workspace, ascend: boolean): string[];
    /**
     * Sets $scope.row to currently selected JMS message.
     * Used in:
     *  - activemq/js/browse.ts
     *  - camel/js/browseEndpoint.ts
     *
     * TODO: remove $scope argument and operate directly on other variables. but it's too much side effects here...
     *
     * @param message
     * @param key unique key inside message that distinguishes between values
     * @param $scope
     */
    function selectCurrentMessage(message: any, key: string, $scope: any): void;
    /**
     * - Adds functions needed for message browsing with details
     * - Adds a watch to deselect all rows after closing the slideout with message details
     * TODO: export these functions too?
     *
     * @param $scope
     * @param fn optional function to call if the selected row was changed
     */
    function decorate($scope: any, fn?: any): void;
    function getBrokerMBean(workspace: Jmx.Workspace, jolokia: any, jmxDomain: string): any;
}
declare namespace ActiveMQ {
    class DestinationController {
        private $scope;
        private workspace;
        private $location;
        private jolokia;
        private localStorage;
        amqJmxDomain: any;
        message: string;
        destinationName: string;
        destinationType: string;
        createDialog: boolean;
        deleteDialog: boolean;
        purgeDialog: boolean;
        constructor($scope: any, workspace: Jmx.Workspace, $location: ng.ILocationService, jolokia: Jolokia.IJolokia, localStorage: Storage);
        private operationSuccess;
        private deleteSuccess;
        private validateDestinationName;
        private isQueue;
        private checkIfDestinationExists;
        validateAndCreateDestination(name: string, destinationType: string): void;
        private createDestination;
        /**
         * When destination name contains "_" like "aaa_bbb", the actual name might be either
         * "aaa_bbb" or "aaa:bbb", so the actual name needs to be checked before removal.
         * @param name destination name
         */
        private restoreRealDestinationName;
        deleteDestination(): void;
        purgeDestination(): void;
        selectedName(): string;
        uncapitalisedDestinationType(): string;
    }
}
declare namespace ActiveMQ {
    const createDestinationComponent: angular.IComponentOptions;
    const deleteQueueComponent: angular.IComponentOptions;
    const deleteTopicComponent: angular.IComponentOptions;
}
declare namespace ActiveMQ {
    const destinationModule: string;
}
declare namespace ActiveMQ {
    class TreeController {
        private $scope;
        private $location;
        private workspace;
        private $element;
        constructor($scope: any, $location: ng.ILocationService, workspace: Jmx.Workspace, $element: JQuery);
        $onInit(): void;
        private updateSelectionFromURL;
        private populateTree;
        private removeTree;
    }
}
declare namespace HawtioTree {
    function getMaxTreeLevel(tree: any): number;
}
declare namespace ActiveMQ {
    class TreeHeaderController {
        private $scope;
        private $element;
        filter: string;
        result: any[];
        constructor($scope: any, $element: JQuery);
        $onInit(): void;
        private search;
        private tree;
        expandAll(): any;
        contractAll(): any;
    }
}
declare namespace ActiveMQ {
    const treeHeaderComponent: angular.IComponentOptions;
    const treeComponent: angular.IComponentOptions;
}
declare namespace ActiveMQ {
    const treeModule: string;
    const treeElementId = "#activemqtree";
}
declare namespace ActiveMQ {
    const activeMQComponent: angular.IComponentOptions;
}
declare namespace ActiveMQ {
    class ActiveMQNavigationService {
        private workspace;
        constructor(workspace: Jmx.Workspace);
        getTabs(): Nav.HawtioTab[];
        private shouldShowBrowseTab;
        private shouldShowSendTab;
        private shouldShowDurableSubscribersTab;
        private shouldShowJobsTab;
        private shouldShowCreateTab;
        private shouldShowDeleteTopicTab;
        private shouldShowDeleteQueueTab;
        private shouldShowQueuesTab;
        private shouldShowTopicsTab;
        private isQueue;
        private isTopic;
        private isQueuesFolder;
        private isTopicsFolder;
        private isJobScheduler;
        private isBroker;
        private getBroker;
    }
}
declare namespace ActiveMQ {
    class ActiveMQNavigationController {
        private $location;
        private activeMQNavigationService;
        tabs: Nav.HawtioTab[];
        constructor($scope: ng.IScope, $location: ng.ILocationService, activeMQNavigationService: ActiveMQNavigationService);
        $onInit(): void;
        goto(tab: Nav.HawtioTab): void;
    }
    const activeMQNavigationComponent: angular.IComponentOptions;
}
declare namespace ActiveMQ {
    const _module: angular.IModule;
}
declare namespace Camel {
    class Context {
        name: string;
        state: string;
        mbeanName: string;
        selected: boolean;
        constructor(name: string, state: string, mbeanName: string);
        isStarted(): boolean;
        isSuspended(): boolean;
    }
}
declare namespace Camel {
    class ContextsService {
        private jolokiaService;
        private treeService;
        constructor(jolokiaService: JVM.JolokiaService, treeService: Jmx.TreeService);
        getContexts(): ng.IPromise<Context[]>;
        getContext(mbeanName: string): ng.IPromise<Context>;
        startContext(context: Context): ng.IPromise<any>;
        startContexts(contexts: Context[]): ng.IPromise<any[]>;
        suspendContext(context: Context): ng.IPromise<any>;
        suspendContexts(contexts: Context[]): ng.IPromise<any[]>;
        stopContext(context: Context): ng.IPromise<any>;
        stopContexts(contexts: Context[]): ng.IPromise<any[]>;
        executeOperationOnContext(operation: string, context: Context): ng.IPromise<any>;
        executeOperationOnContexts(operation: string, contexts: Context[]): ng.IPromise<any[]>;
    }
}
declare namespace Camel {
    class ContextsController {
        private $timeout;
        private $uibModal;
        private workspace;
        private contextsService;
        private startAction;
        private suspendAction;
        private deleteAction;
        toolbarConfig: {
            actionsConfig: {
                primaryActions: {
                    name: string;
                    actionFn: (action: any) => void;
                    isDisabled: boolean;
                }[];
                moreActions: {
                    name: string;
                    actionFn: (action: any) => void;
                    isDisabled: boolean;
                }[];
            };
            isTableView: boolean;
        };
        tableConfig: {
            selectionMatchProp: string;
            onCheckBoxChange: (item: any) => void;
        };
        tableColumns: {
            header: string;
            itemField: string;
        }[];
        contexts: Context[];
        showTable: boolean;
        constructor($timeout: ng.ITimeoutService, $uibModal: any, workspace: Jmx.Workspace, contextsService: ContextsService);
        $onInit(): void;
        private getSelectedContexts;
        private enableDisableActions;
        private updateContexts;
        private removeSelectedContexts;
        private repaintTable;
    }
    const contextsComponent: angular.IComponentOptions;
}
declare namespace Camel {
    class ContextActionsController {
        private $scope;
        private $uibModal;
        private workspace;
        private contextsService;
        context: Context;
        unsubscribe: any;
        constructor($scope: any, $uibModal: any, workspace: Jmx.Workspace, contextsService: ContextsService);
        $onInit(): void;
        $onDestroy(): void;
        start(): void;
        suspend(): void;
        delete(): void;
    }
    const contextActionsComponent: angular.IComponentOptions;
}
declare namespace Camel {
    const contextsModule: string;
}
declare namespace Camel {
    class AddConditionalBreakpointModalController {
        private debugService;
        close: () => void;
        resolve: {
            nodeId: string;
        };
        conditionalBreakpoint: ConditionalBreakpoint;
        error: string;
        constructor(debugService: DebugService);
        add(): void;
    }
    const addConditionalBreakpointModal: angular.IComponentOptions;
}
declare namespace Camel {
    function DebugController($scope: any, $element: any, workspace: Jmx.Workspace, jolokia: Jolokia.IJolokia, localStorage: Storage, documentBase: string, $uibModal: any): void;
}
declare namespace Camel {
    class DebugService {
        private workspace;
        private jolokiaService;
        constructor(workspace: Jmx.Workspace, jolokiaService: JVM.JolokiaService);
        addConditionalBreakpoint(conditionalBreakpoint: ConditionalBreakpoint): ng.IPromise<void>;
    }
}
declare namespace Camel {
    const debugModule: string;
}
declare namespace Pf {
    function filter<T>(items: T[], filterConfig: any): T[];
}
declare namespace Camel {
    class EndpointsStatisticsService {
        private jolokiaService;
        private treeService;
        constructor(jolokiaService: JVM.JolokiaService, treeService: Jmx.TreeService);
        getStatistics(): ng.IPromise<any[]>;
    }
}
declare namespace Camel {
    class EndpointsStatisticsController {
        private endpointsStatisticsService;
        allItems: any[];
        filteredItems: any[];
        toolbarConfig: {
            filterConfig: {
                fields: {
                    id: string;
                    title: string;
                    placeholder: string;
                    filterType: string;
                }[];
                onFilterChange: (filters: any[]) => void;
                appliedFilters: any[];
                resultsCount: number;
            };
            isTableView: boolean;
        };
        tableConfig: {
            selectionMatchProp: string;
            showCheckboxes: boolean;
        };
        tableDtOptions: {
            order: (string | number)[][];
        };
        tableColumns: {
            itemField: string;
            header: string;
        }[];
        constructor(endpointsStatisticsService: EndpointsStatisticsService);
        $onInit(): void;
    }
    const endpointsStatisticsComponent: angular.IComponentOptions;
}
declare namespace Camel {
    const endpointsStatisticsModule: string;
}
declare namespace Camel {
    class Endpoint {
        uri: string;
        state: string;
        mbean: string;
        constructor(uri: string, state: string, mbean: string);
    }
}
declare namespace Camel {
    class EndpointsService {
        private $q;
        private jolokiaService;
        private workspace;
        constructor($q: ng.IQService, jolokiaService: JVM.JolokiaService, workspace: Jmx.Workspace);
        getEndpoints(): ng.IPromise<Endpoint[]>;
        canCreateEndpoints(): boolean;
    }
}
declare namespace Camel {
    class EndpointsController {
        private $location;
        private endpointsService;
        private addAction;
        toolbarConfig: {
            actionsConfig: {
                primaryActions: {
                    name: string;
                    actionFn: (action: any) => void;
                    isDisabled: boolean;
                }[];
            };
            isTableView: boolean;
        };
        tableConfig: {
            selectionMatchProp: string;
            showCheckboxes: boolean;
        };
        tableDtOptions: {
            order: (string | number)[][];
        };
        tableColumns: {
            header: string;
            itemField: string;
        }[];
        endpoints: Endpoint[];
        constructor($location: ng.ILocationService, endpointsService: EndpointsService);
        $onInit(): void;
    }
    const endpointsComponent: angular.IComponentOptions;
}
declare namespace Camel {
    const endpointsModule: string;
}
declare namespace Camel {
    const exchangesComponent: angular.IComponentOptions;
}
declare namespace Camel {
    class ExchangesService {
        private jolokiaService;
        private treeService;
        private workspace;
        constructor(jolokiaService: JVM.JolokiaService, treeService: Jmx.TreeService, workspace: Jmx.Workspace);
        getInflightExchanges(): ng.IPromise<any[]>;
        getBlockedExchanges(): ng.IPromise<any[]>;
        private getExchanges;
        unblockExchange(exchange: any): angular.IPromise<any>;
    }
}
declare namespace Camel {
    class InflightExchangesController {
        private $timeout;
        private exchangesService;
        readonly reloadDelay = 10000;
        exchanges: any[];
        promise: ng.IPromise<any>;
        constructor($timeout: ng.ITimeoutService, exchangesService: ExchangesService);
        $onInit(): void;
        $onDestroy(): void;
        loadDataPeriodically(): void;
        cancelTimer(): void;
    }
    const inflightExchangesComponent: angular.IComponentOptions;
}
declare namespace Camel {
    class BlockedExchangesController {
        private $timeout;
        private $uibModal;
        private exchangesService;
        readonly reloadDelay = 10000;
        exchanges: any[];
        promise: ng.IPromise<any>;
        constructor($timeout: ng.ITimeoutService, $uibModal: any, exchangesService: ExchangesService);
        $onInit(): void;
        $onDestroy(): void;
        loadDataPeriodically(): void;
        cancelTimer(): void;
        unblock(exchange: any): void;
    }
    const blockedExchangesComponent: angular.IComponentOptions;
}
declare namespace Camel {
    const confirmUnblockExchangeComponent: angular.IComponentOptions;
}
declare namespace Camel {
    const exchangesModule: string;
}
declare namespace JVM {
    class JolokiaService {
        private $q;
        private jolokia;
        constructor($q: ng.IQService, jolokia: Jolokia.IJolokia);
        getMBean(objectName: string): ng.IPromise<any>;
        getMBeans(objectNames: string[]): ng.IPromise<any[]>;
        getAttribute(objectName: string, attribute: string): ng.IPromise<any>;
        getAttributes(objectName: string, attributes: string[]): ng.IPromise<object>;
        setAttribute(objectName: string, attribute: string, value: any): ng.IPromise<any>;
        setAttributes(objectName: string, attributes: string[], values: any[]): ng.IPromise<any[]>;
        execute(objectName: string, operation: string, ...args: any[]): ng.IPromise<any>;
        executeMany(objectNames: string[], operation: string, ...args: any[]): ng.IPromise<any[]>;
        search(mbeanPattern: string): ng.IPromise<any>;
    }
}
declare namespace Camel {
    class ProfileService {
        private treeService;
        private jolokiaService;
        constructor(treeService: Jmx.TreeService, jolokiaService: JVM.JolokiaService);
        getProfile(): ng.IPromise<any[]>;
    }
}
declare namespace Camel {
    class ProfileController {
        private $interval;
        private profileService;
        readonly reloadDelay = 10000;
        reloadTask: ng.IPromise<any>;
        profile: any[];
        constructor($interval: ng.IIntervalService, profileService: ProfileService);
        $onInit(): void;
        $onDestroy(): void;
        loadDataPeriodically(): void;
        loadData(): void;
        cancelReloadTask(): void;
    }
    const profileComponent: angular.IComponentOptions;
}
declare namespace Camel {
    const profileModule: string;
}
declare namespace Camel {
    class Property {
        name: string;
        value: string;
        description: string;
        constructor(name: string, value: string, description: string);
        static sortByName(a: any, b: any): 1 | 0 | -1;
    }
}
declare namespace Camel {
    class PropertiesService {
        getDefinedProperties(schemaProperties: {}): Property[];
        getDefaultProperties(schemaProperties: {}): Property[];
        getUndefinedProperties(schemaProperties: {}): Property[];
    }
}
declare namespace Camel {
    function PropertiesComponentController($scope: any, workspace: Jmx.Workspace, jolokia: Jolokia.IJolokia, documentBase: string, propertiesService: PropertiesService): void;
}
declare namespace Camel {
    function PropertiesDataFormatController($scope: any, workspace: Jmx.Workspace, jolokia: Jolokia.IJolokia, documentBase: string, propertiesService: PropertiesService): void;
}
declare namespace Camel {
    function PropertiesEndpointController($scope: any, workspace: Jmx.Workspace, jolokia: Jolokia.IJolokia, documentBase: string, propertiesService: PropertiesService): void;
}
declare namespace Camel {
    function PropertiesRouteController($scope: any, workspace: Jmx.Workspace, propertiesService: PropertiesService): void;
}
declare namespace Camel {
    const propertyListComponent: angular.IComponentOptions;
}
declare namespace Camel {
    const propertiesModule: string;
}
declare namespace Camel {
    interface RestService {
        url: string;
        method: string;
        consumes: string;
        produces: string;
        routeId: string;
    }
}
declare namespace Camel {
    class RestServicesService {
        private jolokiaService;
        private workspace;
        constructor(jolokiaService: JVM.JolokiaService, workspace: Jmx.Workspace);
        getRestServices(): ng.IPromise<RestService[]>;
    }
}
declare namespace Camel {
    class RestServicesController {
        private restServicesService;
        toolbarConfig: {
            filterConfig: {
                fields: ({
                    id: string;
                    title: string;
                    placeholder: string;
                    filterType: string;
                    filterValues?: undefined;
                } | {
                    id: string;
                    title: string;
                    placeholder: string;
                    filterType: string;
                    filterValues: string[];
                })[];
                onFilterChange: () => void;
                resultsCount: number;
            };
            isTableView: boolean;
        };
        tableConfig: {
            selectionMatchProp: string;
            showCheckboxes: boolean;
        };
        tableOptions: {
            order: (string | number)[][];
        };
        tableColumns: {
            header: string;
            itemField: string;
        }[];
        tableItems: RestService[];
        restServices: RestService[];
        constructor(restServicesService: RestServicesService);
        $onInit(): void;
    }
    const restServicesComponent: angular.IComponentOptions;
}
declare namespace Camel {
    const restServicesModule: string;
}
declare namespace Camel {
    class Route {
        name: string;
        state: string;
        mbean: string;
        uptime: string;
        exchangesCompleted: number;
        exchangesFailed: number;
        failuresHandled: number;
        exchangesTotal: number;
        exchangesInflight: number;
        meanProcessingTimeMillis: number;
        selected: boolean;
        constructor(name: string, state: string, mbean: string, uptime: string, exchangesCompleted: number, exchangesFailed: number, failuresHandled: number, exchangesTotal: number, exchangesInflight: number, meanProcessingTimeMillis: number);
        readonly meanProcessingTime: string;
        isStarted(): boolean;
        isStopped(): boolean;
    }
}
declare namespace Camel {
    class RoutesService {
        private jolokiaService;
        private workspace;
        private Operation;
        constructor(jolokiaService: JVM.JolokiaService, workspace: Jmx.Workspace);
        getRoute(objectName: string): ng.IPromise<Route>;
        getRoutes(objectNames: string[]): ng.IPromise<Route[]>;
        private buildRoute;
        startRoute(route: Route): ng.IPromise<any>;
        startRoutes(routes: Route[]): ng.IPromise<any>;
        stopRoute(route: Route): ng.IPromise<any>;
        stopRoutes(routes: Route[]): ng.IPromise<any>;
        removeRoute(route: Route): ng.IPromise<any>;
        removeRoutes(routes: Route[]): ng.IPromise<any>;
        private executeOperationOnRoutes;
        canStartRoutes(routes: Route[]): boolean;
        canStopRoutes(routes: Route[]): boolean;
        canDeleteRoutes(routes: Route[]): boolean;
        private canExecuteOperationOnRoutes;
    }
}
declare namespace Camel {
    class RoutesController {
        private $timeout;
        private $uibModal;
        private workspace;
        private treeService;
        private routesService;
        private startAction;
        private stopAction;
        private deleteAction;
        toolbarConfig: any;
        tableConfig: {
            selectionMatchProp: string;
            onCheckBoxChange: (item: any) => void;
        };
        tableColumns: {
            header: string;
            itemField: string;
        }[];
        routes: Route[];
        showTable: boolean;
        constructor($timeout: ng.ITimeoutService, $uibModal: any, workspace: Jmx.Workspace, treeService: Jmx.TreeService, routesService: RoutesService);
        $onInit(): void;
        private configureToolbar;
        private getSelectedRoutes;
        private enableDisableActions;
        private loadRoutes;
        private updateRoutes;
        private removeSelectedRoutes;
        private repaintTable;
    }
    const routesComponent: angular.IComponentOptions;
}
declare namespace Camel {
    class RouteActionsController {
        private $scope;
        private $uibModal;
        private workspace;
        private routesService;
        route: Route;
        unsubscribe: any;
        constructor($scope: any, $uibModal: any, workspace: Jmx.Workspace, routesService: RoutesService);
        $onInit(): void;
        $onDestroy(): void;
        start(): void;
        stop(): void;
        delete(): void;
    }
    const routeActionsComponent: angular.IComponentOptions;
}
declare namespace Camel {
    const routesModule: string;
}
declare namespace Camel {
    class TreeController {
        private $scope;
        private $location;
        private workspace;
        private jolokia;
        private $element;
        constructor($scope: ng.IScope, $location: ng.ILocationService, workspace: Jmx.Workspace, jolokia: Jolokia.IJolokia, $element: JQuery);
        $onInit(): void;
        private updateSelectionFromURL;
        private populateTree;
        private removeTree;
    }
}
declare namespace Camel {
    class TreeHeaderController {
        private $scope;
        private $element;
        filter: string;
        result: any[];
        constructor($scope: any, $element: JQuery);
        $onInit(): void;
        private search;
        private tree;
        expandAll(): any;
        contractAll(): any;
    }
}
declare namespace Camel {
    const treeHeaderComponent: angular.IComponentOptions;
    const treeComponent: angular.IComponentOptions;
}
declare namespace Camel {
    const treeModule: string;
    const treeElementId = "#cameltree";
}
declare namespace Camel {
    const typeConvertersComponent: angular.IComponentOptions;
}
declare namespace Camel {
    class TypeConvertersStatistics {
        AttemptCounter: number;
        HitCounter: number;
        MissCounter: number;
        FailedCounter: number;
        constructor(object: any);
        reset(): void;
    }
}
declare namespace Camel {
    class TypeConverter {
        from: string;
        to: string;
        constructor(from: string, to: string);
    }
}
declare namespace Camel {
    class TypeConvertersService {
        private jolokiaService;
        private treeService;
        constructor(jolokiaService: JVM.JolokiaService, treeService: Jmx.TreeService);
        enableStatistics(): ng.IPromise<any>;
        disableStatistics(): ng.IPromise<any>;
        resetStatistics(): ng.IPromise<any>;
        getStatistics(): ng.IPromise<any>;
        getTypeConverters(): ng.IPromise<TypeConverter[]>;
        private getTypeConverterObjectName;
    }
}
declare namespace Camel {
    class TypeCovertersStatisticsController {
        private $timeout;
        private typeConvertersService;
        reloadDelay: number;
        statistics: TypeConvertersStatistics;
        promise: any;
        enableStatisticsAction: {
            name: string;
            actionFn: () => void;
        };
        disableStatisticsAction: {
            name: string;
            actionFn: () => void;
        };
        resetStatisticsAction: {
            name: string;
            actionFn: () => void;
            isDisabled: boolean;
        };
        toolbarConfig: {
            actionsConfig: {
                primaryActions: {
                    name: string;
                    actionFn: () => void;
                }[];
            };
        };
        constructor($timeout: ng.ITimeoutService, typeConvertersService: TypeConvertersService);
        enableStatistics(): void;
        showDisableStatisticsButton(): void;
        disableStatistics(): void;
        showEnableStatisticsButton(): void;
        resetStatistics(): void;
        $onDestroy(): void;
        loadDataPeriodically(): void;
        cancelTimer(): void;
    }
    const typeConvertersStatisticsComponent: angular.IComponentOptions;
}
declare namespace Camel {
    class TypeCovertersTableController {
        private typeConvertersService;
        allTypeConverters: TypeConverter[];
        typeConverters: TypeConverter[];
        toolbarConfig: {
            filterConfig: {
                fields: {
                    id: string;
                    title: string;
                    placeholder: string;
                    filterType: string;
                }[];
                onFilterChange: (filters: any[]) => void;
                resultsCount: number;
            };
            isTableView: boolean;
        };
        tableConfig: {
            selectionMatchProp: string;
            showCheckboxes: boolean;
        };
        tableDtOptions: {
            order: (string | number)[][];
        };
        tableColumns: {
            header: string;
            itemField: string;
        }[];
        constructor(typeConvertersService: TypeConvertersService);
        $onInit(): void;
        applyFilters(filters: any[]): void;
    }
    const typeConvertersTableComponent: angular.IComponentOptions;
}
declare namespace Camel {
    const typeConvertersModule: string;
}
declare namespace Camel {
    /**
     * Define the default categories for endpoints and map them to endpoint names
     * @property
     * @for Camel
     * @type {Object}
     */
    var endpointCategories: {
        bigdata: {
            label: string;
            endpoints: string[];
            endpointIcon: string;
        };
        database: {
            label: string;
            endpoints: string[];
            endpointIcon: string;
        };
        cloud: {
            label: string;
            endpoints: string[];
        };
        core: {
            label: string;
            endpoints: string[];
        };
        messaging: {
            label: string;
            endpoints: string[];
            endpointIcon: string;
        };
        mobile: {
            label: string;
            endpoints: string[];
        };
        sass: {
            label: string;
            endpoints: string[];
        };
        social: {
            label: string;
            endpoints: string[];
        };
        storage: {
            label: string;
            endpointIcon: string;
            endpoints: string[];
        };
        template: {
            label: string;
            endpoints: string[];
        };
    };
    /**
     * Maps endpoint names to a category object
     * @property
     * @for Camel
     * @type {Object}
     */
    var endpointToCategory: {};
    var endpointIcon: string;
    /**
     *  specify custom label & icon properties for endpoint names
     * @property
     * @for Camel
     * @type {Object}
     */
    var endpointConfigurations: {
        drools: {
            icon: string;
        };
        quartz: {
            icon: string;
        };
        facebook: {
            icon: string;
        };
        salesforce: {
            icon: string;
        };
        sap: {
            icon: string;
        };
        "sap-netweaver": {
            icon: string;
        };
        timer: {
            icon: string;
        };
        twitter: {
            icon: string;
        };
        weather: {
            icon: string;
        };
    };
    /**
     * Define the default form configurations
     * @property
     * @for Camel
     * @type {Object}
     */
    var endpointForms: {
        file: {
            tabs: {
                'Options': string[];
            };
        };
        activemq: {
            tabs: {
                'Connection': string[];
                'Producer': string[];
                'Consumer': string[];
                'Reply': string[];
                'Options': string[];
            };
        };
    };
    function getEndpointIcon(endpointName: any): any;
    function getEndpointConfig(endpointName: any, category: any): any;
    function getEndpointCategory(endpointName: string): any;
    function getConfiguredCamelModel(): any;
    function initEndpointChooserScope($scope: any, $location: any, localStorage: Storage, workspace: Jmx.Workspace, jolokia: Jolokia.IJolokia): void;
}
declare var _apacheCamelModel: any;
declare namespace Camel {
    const pluginName: string;
    const log: Logging.Logger;
    const jmxDomain: string;
    const defaultMaximumLabelWidth = 34;
    const defaultCamelMaximumTraceOrDebugBodyLength = 5000;
    const defaultCamelTraceOrDebugIncludeStreams = false;
    const defaultCamelRouteMetricMaxSeconds = 10;
    const defaultHideOptionDocumentation = false;
    const defaultHideOptionDefaultValue = false;
    const defaultHideOptionUnusedValue = false;
    var _apacheCamelModel: any;
    /**
     * Returns if the given CamelContext has any rest services
     *
     * @param workspace
     * @param jolokia
     * @returns {boolean}
     */
    function hasRestServices(workspace: Jmx.Workspace, jolokia: Jolokia.IJolokia): boolean;
    /**
     * Looks up the route XML for the given context and selected route and
     * processes the selected route's XML with the given function
     * @method processRouteXml
     * @param {Workspace} workspace
     * @param {Object} jolokia
     * @param {Folder} folder
     * @param {Function} onRoute
     */
    function processRouteXml(workspace: Jmx.Workspace, jolokia: Jolokia.IJolokia, folder: Jmx.Folder, onRoute: (route: Element) => void): void;
    /**
     * Returns the URI string for the given EIP pattern node or null if it is not applicable
     * @method getRouteNodeUri
     * @param {Object} node
     * @return {String}
     */
    function getRouteNodeUri(node: any): string;
    /**
     * Returns the JSON data for the camel folder; extracting it from the associated
     * routeXmlNode or using the previously extracted and/or edited JSON
     * @method getRouteFolderJSON
     * @param {Folder} folder
     * @param {Object} answer
     * @return {Object}
     */
    function getRouteFolderJSON(folder: any, answer?: {}): any;
    function getRouteNodeJSON(routeXmlNode: any, answer?: {}): {};
    function increaseIndent(currentIndent: string, indentAmount?: string): string;
    function setRouteNodeJSON(routeXmlNode: any, newData: any, indent: any): void;
    function getRouteNodeIcon(nodeSettingsOrXmlNode: any): string;
    /**
     * Parse out the currently selected endpoint's name to be used when invoking on a
     * context operation that wants an endpoint name
     * @method getSelectedEndpointName
     * @param {Workspace} workspace
     * @return {any} either a string that is the endpoint name or null if it couldn't be parsed
     */
    function getSelectedEndpointName(workspace: Jmx.Workspace): any;
    /**
     * Escapes the given URI text so it can be used in a JMX name
     */
    function escapeEndpointUriNameForJmx(uri: any): any;
    /**
     * Returns the mbean for the currently selected camel context and the name of the currently
     * selected endpoint for JMX operations on a context that require an endpoint name.
     * @method
     * @param workspace
     * @return {{uri: string, mbean: string}} either value could be null if there's a parse failure
     */
    function getContextAndTargetEndpoint(workspace: Jmx.Workspace): {
        uri: any;
        mbean: string;
    };
    /**
     * Returns the cached Camel XML route node stored in the current tree selection Folder
     * @method
     */
    function getSelectedRouteNode(workspace: Jmx.Workspace): any;
    /**
     * Returns true when the selected node is a Camel XML route node, false otherwise.
     * @method
     */
    function isRouteNode(workspace: Jmx.Workspace): boolean;
    /**
     * Looks up the given node name in the Camel schema
     * @method
     */
    function getCamelSchema(nodeIdOrDefinition: any): any;
    /**
     * Returns true if the given nodeId is a route, endpoint or pattern
     * (and not some nested type like a data format)
     * @method
     */
    function isCamelPattern(nodeId: any): boolean;
    /**
     * Looks up the Camel language settings for the given language name
     * @method
     */
    function camelLanguageSettings(nodeName: any): any;
    function isCamelLanguage(nodeName: any): boolean;
    /**
     * Adds the route children to the given folder for each step in the route
     * @method
     */
    function loadRouteChildren(folder: Jmx.Folder, route: Element, workspace: Jmx.Workspace): Jmx.NodeSelection[];
    /**
     * Returns the root JMX Folder of the camel mbeans
     */
    function getRootCamelFolder(workspace: Jmx.Workspace): Jmx.Folder;
    /**
     * Returns the JMX folder for the camel context
     */
    function getCamelContextFolder(workspace: Jmx.Workspace, camelContextId: string): Jmx.Folder;
    /**
     * Returns the mbean for the given camel context ID or null if it cannot be found
     */
    function getCamelContextMBean(workspace: Jmx.Workspace, camelContextId: any): string | null;
    function getFolderCamelNodeId(folder: any): any;
    /**
     * Rebuilds the DOM tree from the tree node and performs all the various hacks
     * to turn the folder / JSON / model into valid camel XML
     * such as renaming language elements from <language expression="foo" language="bar/>
     * to <bar>foo</bar>
     * and changing <endpoint> into either <from> or <to>
     * @method
     * @param treeNode is either the Node from the tree widget (with the real Folder in the data property) or a Folder
     */
    function createFolderXmlTree(treeNode: any, xmlNode: any, indent?: string): any;
    function updateRouteNodeLabelAndTooltip(folder: Jmx.Folder, routeXmlNode: any, nodeSettings: any): any;
    /**
     * Returns the selected camel context object name for the given selection or null if it cannot be found
     * @method
     */
    function getSelectionCamelContextMBean(workspace: Jmx.Workspace): string;
    /**
     * Returns the selected camel context object name for the given selection or null if it cannot be found
     * @method
     */
    function getSelectionCamelContext(workspace: Jmx.Workspace): Jmx.NodeSelection;
    /**
     * When lazy loading route info (using dumpRoutesAsXml() operation) we need MBean name from the folder
     * and *not* from the selection
     * @param {Workspace} workspace
     * @param {Folder} folder
     */
    function getExpandingFolderCamelContextMBean(workspace: Jmx.Workspace, folder: Jmx.Folder): string;
    function getSelectionCamelContextEndpoints(workspace: Jmx.Workspace): Jmx.NodeSelection;
    /**
     * Returns the selected camel trace mbean for the given selection or null if it cannot be found
     * @method
     */
    function getSelectionCamelTraceMBean(workspace: Jmx.Workspace): string;
    function getSelectionCamelDebugMBean(workspace: Jmx.Workspace): string;
    function getSelectionCamelTypeConverter(workspace: Jmx.Workspace): string;
    function getSelectionCamelRestRegistry(workspace: Jmx.Workspace): string;
    function getSelectionCamelEndpointRuntimeRegistry(workspace: Jmx.Workspace): string;
    function getSelectionCamelInflightRepository(workspace: Jmx.Workspace): string;
    function getSelectionCamelBlockedExchanges(workspace: Jmx.Workspace): string;
    function getSelectionCamelRouteMetrics(workspace: Jmx.Workspace): string;
    function getContextId(workspace: Jmx.Workspace): string;
    function iconClass(state: string): "green fa fa-play-circle" | "fa fa-pause" | "orange fa fa-off";
    function getSelectedRouteId(workspace: Jmx.Workspace, folder?: Jmx.NodeSelection): any;
    /**
     * Returns the selected camel route mbean for the given route id
     * @method
     */
    function getSelectionRouteMBean(workspace: Jmx.Workspace, routeId: String): string;
    function getCamelVersion(workspace: Jmx.Workspace, jolokia: any): string;
    function createMessageFromXml(exchange: any): {
        headers: {};
        headerTypes: {};
        id: any;
        uid: string;
        timestamp: string;
        headerHtml: string;
    };
    function humanizeJavaType(type: string): string;
    function createBrowseGridOptions(): {
        selectedItems: any[];
        data: string;
        displayFooter: boolean;
        showFilter: boolean;
        showColumnMenu: boolean;
        enableColumnResize: boolean;
        enableColumnReordering: boolean;
        filterOptions: {
            filterText: string;
        };
        selectWithCheckboxOnly: boolean;
        showSelectionCheckbox: boolean;
        maintainColumnRatios: boolean;
        columnDefs: {
            field: string;
            displayName: string;
            cellTemplate: string;
        }[];
    };
    function loadRouteXmlNodes($scope: any, doc: any, selectedRouteId: any, nodes: any, links: any, width: any): void;
    function addRouteXmlChildren($scope: any, parent: any, nodes: any, links: any, parentId: any, parentX: any, parentY: any, parentNode?: any): any[];
    /**
     * Returns an object of all the CamelContext MBeans keyed by their id
     * @method
     */
    function camelContextMBeansById(workspace: Jmx.Workspace): {
        [id: string]: Jmx.Folder;
    };
    /**
     * Returns an object of all the CamelContext MBeans keyed by the component name
     * @method
     */
    function camelContextMBeansByComponentName(workspace: Jmx.Workspace): {};
    /**
     * Returns an object of all the CamelContext MBeans keyed by the route ID
     * @method
     */
    function camelContextMBeansByRouteId(workspace: Jmx.Workspace): {};
    /**
     * Returns true if we should ignore ID values for labels in camel diagrams
     * @method
     */
    function ignoreIdForLabel(localStorage: any): boolean;
    /**
     * Returns the maximum width of a label before we start to truncate
     * @method
     */
    function maximumLabelWidth(localStorage: any): any;
    /**
     * Returns the max body length for tracer and debugger
     * @method
     */
    function maximumTraceOrDebugBodyLength(localStorage: any): any;
    /**
     * Returns whether to include streams body for tracer and debugger
     * @method
     */
    function traceOrDebugIncludeStreams(localStorage: any): boolean;
    /**
     * Returns true if we should show inflight counter in Camel route diagram
     * @method
     */
    function showInflightCounter(localStorage: any): boolean;
    /**
     * Returns the max value for seconds in the route metrics UI
     * @method
     */
    function routeMetricMaxSeconds(localStorage: any): any;
    /**
     * Whether to hide the documentation for the options
     * @method
     */
    function hideOptionDocumentation(localStorage: any): boolean;
    /**
     * Whether to hide options which uses default values
     * @method
     */
    function hideOptionDefaultValue(localStorage: any): boolean;
    /**
     * Whether to hide options which have unused/empty values
     * @method
     */
    function hideOptionUnusedValue(localStorage: any): boolean;
    /**
     * Function to highlight the selected toNode in the nodes graph
     *
     * @param nodes the nodes
     * @param toNode the node to highlight
     */
    function highlightSelectedNode(nodes: any, toNode: any): void;
    /**
     * Is the currently selected Camel version equal or greater than
     *
     * @param major   major version as number
     * @param minor   minor version as number
     */
    function isCamelVersionEQGT(major: any, minor: any, workspace: any, jolokia: any): boolean;
    /**
     * Determines whether the endpoint supports browse operations
     * @param endpoint The selected endpoint JMX tree node
     */
    function isBrowsableEndpoint(endpoint: Jmx.NodeSelection): boolean;
}
declare namespace Camel {
    class CamelTreeService {
        private treeService;
        constructor(treeService: Jmx.TreeService);
        getSelectedRouteId(): ng.IPromise<string>;
    }
}
declare namespace Camel {
    class CamelNavigationService {
        private workspace;
        private jolokia;
        constructor(workspace: Jmx.Workspace, jolokia: Jolokia.IJolokia);
        getTabs(): Nav.HawtioTab[];
    }
}
declare namespace Camel {
    class CamelNavigationController {
        private $location;
        private camelNavigationService;
        private workspace;
        tabs: Nav.HawtioTab[];
        constructor($scope: ng.IScope, $location: ng.ILocationService, camelNavigationService: CamelNavigationService, workspace: Jmx.Workspace);
        $onInit(): void;
        goto(tab: Nav.HawtioTab): void;
    }
    const camelNavigationComponent: angular.IComponentOptions;
}
declare namespace Camel {
    const camelComponent: angular.IComponentOptions;
}
declare namespace Camel {
    const _module: angular.IModule;
}
declare namespace Karaf {
    const pluginName: string;
    const log: Logging.Logger;
    function setSelect(selection: any, group: any): any;
    function installRepository(workspace: any, jolokia: any, uri: any, success: any, error: any): void;
    function uninstallRepository(workspace: any, jolokia: any, uri: any, success: any, error: any): void;
    function installFeature(workspace: any, jolokia: any, feature: any, version: any, success: any, error: any): void;
    function uninstallFeature(workspace: any, jolokia: any, feature: any, version: any, success: any, error: any): void;
    function toCollection(values: any): any;
    function featureLinks(workspace: any, name: any, version: any): string;
    function extractFeature(attributes: any, name: any, version: any): any;
    function isPlatformBundle(symbolicName: string): boolean;
    function isActiveMQBundle(symbolicName: string): boolean;
    function isCamelBundle(symbolicName: string): boolean;
    function isCxfBundle(symbolicName: string): boolean;
    function populateFeaturesAndRepos(attributes: any, features: any, repositories: any): void;
    function createScrComponentsView(workspace: any, jolokia: any, components: any): any[];
    function getComponentStateDescription(state: any): "Enabled" | "Active" | "Unsatisfied" | "Activating" | "Registered" | "Factory" | "Deactivating" | "Destroying" | "Disabling" | "Disposing" | "Unknown";
    function getAllComponents(workspace: any, jolokia: any): any;
    function getComponentByName(workspace: any, jolokia: any, componentName: any): any;
    function isComponentActive(workspace: any, jolokia: any, component: any): any;
    function getComponentState(workspace: any, jolokia: any, component: any): any;
    function activateComponent(workspace: any, jolokia: any, component: any, success: any, error: any): void;
    function deactivateComponent(workspace: any, jolokia: any, component: any, success: any, error: any): void;
    function populateDependencies(attributes: any, dependencies: any, features: any): void;
    function getSelectionFeaturesMBean(workspace: Jmx.Workspace): string;
    function getSelectionFeaturesMBeanAsync(workspace: Jmx.Workspace, $q: ng.IQService): ng.IPromise<string>;
    function getSelectionScrMBean(workspace: Jmx.Workspace): string;
    function getSelectionScrMBeanAsync(workspace: Jmx.Workspace, $q: ng.IQService): ng.IPromise<string>;
}
declare namespace Osgi {
    interface Bundle {
        id: number;
        name: string;
        location: string;
        symbolicName: string;
        state: string;
        version: string;
        startLevel: number;
        fragment: boolean;
    }
}
declare namespace Osgi {
    const pluginName: string;
    const log: Logging.Logger;
    function defaultBundleValues(workspace: Jmx.Workspace, $scope: any, values: any): any;
    function getStateStyle(prefix: string, state: string): string;
    function defaultServiceValues(workspace: Jmx.Workspace, $scope: any, values: any): any;
    function defaultPackageValues(workspace: Jmx.Workspace, $scope: any, values: any): any[];
    function parseActualPackages(packages: string[]): {};
    function parseManifestHeader(headers: {}, name: string): {};
    function toCollection(values: any): any[];
    function labelBundleLinks(workspace: any, values: any, allValues: any): {
        label: any;
        url: string;
    }[];
    function bundleLinks(workspace: any, values: any): string;
    function bundleUrls(workspace: any, values: any): any[];
    function pidLinks(workspace: any, values: any): string;
    /**
     * Finds a bundle by id
     *
     * @method findBundle
     * @for Osgi
     * @param {String} bundleId
     * @param {Array} values
     * @return {any}
     *
     */
    function findBundle(bundleId: any, values: any): string;
    function getSelectionBundleMBean(workspace: Jmx.Workspace): string;
    /**
     * Walks the tree looking in the first child all the way down until we find an objectName
     * @method findFirstObjectName
     * @for Osgi
     * @param {Folder} node
     * @return {String}
     *
     */
    function findFirstObjectName(node: any): any;
    function getSelectionFrameworkMBean(workspace: Jmx.Workspace): string;
    function getSelectionFrameworkMBeanAsync(workspace: Jmx.Workspace, $q: ng.IQService): ng.IPromise<string>;
    function getSelectionServiceMBean(workspace: Jmx.Workspace): string;
    function getSelectionServiceMBeanAsync(workspace: Jmx.Workspace, $q: ng.IQService): ng.IPromise<string>;
    function getSelectionPackageMBean(workspace: Jmx.Workspace): string;
    function getSelectionPackageMBeanAsync(workspace: Jmx.Workspace, $q: ng.IQService): ng.IPromise<string>;
    function getSelectionConfigAdminMBean(workspace: Jmx.Workspace): string;
    function getSelectionConfigAdminMBeanAsync(workspace: Jmx.Workspace, $q: ng.IQService): ng.IPromise<string>;
    function getMetaTypeMBean(workspace: Jmx.Workspace): string;
    function getProfileMetadataMBean(workspace: Jmx.Workspace): string;
    function getHawtioOSGiToolsMBean(workspace: Jmx.Workspace): string;
    function getHawtioConfigAdminMBean(workspace: Jmx.Workspace): string;
    /**
     * Creates a link to the given configuration pid and/or factoryPid
     */
    function createConfigPidLink($scope: any, workspace: any, pid: any, isFactory?: boolean): string;
    /**
     * Creates a path to the given configuration pid and/or factoryPid
     */
    function createConfigPidPath($scope: any, pid: any, isFactory?: boolean): string;
    function getConfigurationProperties(workspace: any, jolokia: any, pid: any, onDataFn: any): any;
    /**
     * For a pid of the form "foo.generatedId" for a pid "foo" or "foo.bar" remove the "foo." prefix
     */
    function removeFactoryPidPrefix(pid: any, factoryPid: any): any;
    function runWhenTreeReady(fn: () => any, workspace: Jmx.Workspace, $q: ng.IQService): ng.IPromise<any>;
}
declare namespace Osgi {
    class BundlesService {
        private workspace;
        private jolokiaService;
        constructor(workspace: Jmx.Workspace, jolokiaService: JVM.JolokiaService);
        getBundles(): ng.IPromise<Bundle[]>;
        startBundles(bundles: Bundle[]): ng.IPromise<string>;
        stopBundles(bundles: Bundle[]): ng.IPromise<string>;
        updateBundles(bundles: Bundle[]): ng.IPromise<string>;
        refreshBundles(bundles: Bundle[]): ng.IPromise<string>;
        uninstallBundles(bundles: Bundle[]): ng.IPromise<string>;
        installBundle(bundleUrl: string): ng.IPromise<string>;
        private handleResponse;
    }
}
declare namespace Osgi {
    class BundlesController {
        private bundlesService;
        private workspace;
        private static FILTER_FUNCTIONS;
        private readonly startAction;
        private readonly stopAction;
        private readonly refreshAction;
        private readonly updateAction;
        private readonly uninstallAction;
        private readonly tableConfig;
        private readonly toolbarConfig;
        private readonly tableColumns;
        private tableItems;
        private bundles;
        private loading;
        constructor(bundlesService: BundlesService, workspace: Jmx.Workspace);
        $onInit(): void;
        private loadBundles;
        private toolbarActions;
        private applyFilters;
        private getSelectedBundles;
        private enableDisableActions;
    }
    const bundlesComponent: angular.IComponentOptions;
}
declare namespace Osgi {
    class InstallBundleController {
        private bundlesService;
        private workspace;
        loading: boolean;
        frameworkMBean: string;
        bundles: Bundle[];
        constructor(bundlesService: BundlesService, workspace: Jmx.Workspace);
        install(bundleUrl: string): void;
        findBundleByUrl(bundleUrl: string): Bundle;
        installDisabled(bundleUrl: string): boolean;
    }
    const installBundleComponent: angular.IComponentOptions;
}
declare namespace Osgi {
    const bundlesModule: string;
}
declare namespace Osgi {
    class ConfigurationPropertyAddModalController {
        property: ConfigurationProperty;
    }
    const configurationPropertyAddModal: angular.IComponentOptions;
}
declare namespace Osgi {
    const configurationPropertyDeleteModal: angular.IComponentOptions;
}
declare namespace Osgi {
    const configurationPropertyEditModal: angular.IComponentOptions;
}
declare namespace Osgi {
    class ConfigurationProperty {
        key: string;
        value: string;
        constructor(key: string, value: string);
    }
}
declare namespace Osgi {
    class Configuration {
        id: string;
        properties: ConfigurationProperty[];
        constructor(id: string, properties: ConfigurationProperty[]);
        getPropertiesAsJson(): string;
    }
}
declare namespace Osgi {
    class ConfigurationController {
        private $routeParams;
        private $uibModal;
        private configurationService;
        toolbarConfig: {
            actionsConfig: {
                primaryActions: any[];
            };
            isTableView: boolean;
        };
        tableConfig: {
            selectionMatchProp: string;
            showCheckboxes: boolean;
        };
        tableColumns: {
            header: string;
            itemField: string;
        }[];
        tableMenuActions: any[];
        configuration: Configuration;
        constructor($routeParams: ng.route.IRouteParamsService, $uibModal: angular.ui.bootstrap.IModalService, configurationService: ConfigurationService);
        $onInit(): void;
        loadConfiguration(): void;
        getToolbarActions(): any[];
        getTableMenuActions(): any[];
        addAction: () => void;
        editAction: (action: any, property: ConfigurationProperty) => void;
        deleteAction: (action: any, property: ConfigurationProperty) => void;
    }
    const configurationComponent: angular.IComponentOptions;
}
declare namespace Osgi {
    class ConfigurationService {
        private workspace;
        private jolokiaService;
        private hawtioConfigAdminMBean;
        private configAdminMBean;
        constructor(workspace: Jmx.Workspace, jolokiaService: JVM.JolokiaService);
        isReadWrite(): boolean;
        getConfiguration(id: string): ng.IPromise<Configuration>;
        addProperty(configuration: Configuration, property: ConfigurationProperty): ng.IPromise<Configuration>;
        replaceProperty(configuration: Configuration, oldProperty: ConfigurationProperty, newProperty: ConfigurationProperty): ng.IPromise<Configuration>;
        deleteProperty(configuration: Configuration, property: ConfigurationProperty): ng.IPromise<Configuration>;
        saveAndLoadConfiguration(configuration: Configuration): ng.IPromise<Configuration>;
        hasRightsToAddProperty(): boolean;
        hasRightsToEditProperties(): boolean;
        hasRightsToDeleteProperties(): boolean;
    }
}
declare namespace Osgi {
    const configurationModule: string;
}
declare namespace Osgi {
    interface Framework {
        startLevel: number;
        initialBundleStartLevel: number;
    }
}
declare namespace Osgi {
    class FrameworkService {
        private $q;
        private workspace;
        private jolokiaService;
        static FRAMEWORK_MBEAN_ATTRIBUTES: string[];
        constructor($q: ng.IQService, workspace: Jmx.Workspace, jolokiaService: JVM.JolokiaService);
        getFramework(): ng.IPromise<Framework>;
        updateConfiguration(framework: Framework): angular.IPromise<any[]>;
    }
}
declare namespace Osgi {
    class FrameworkController {
        frameworkService: FrameworkService;
        bundlesService: BundlesService;
        private attributesService;
        private workspace;
        private $q;
        private framework;
        private maxBundleStartLevel;
        private loading;
        private saveInProgress;
        private canSave;
        constructor(frameworkService: FrameworkService, bundlesService: BundlesService, attributesService: Jmx.AttributesService, workspace: Jmx.Workspace, $q: ng.IQService);
        $onInit(): void;
        private fetchPermissions;
        updateFrameworkConfiguration(): void;
        saveDisabled(): boolean;
        hasEditPermission(): boolean;
    }
    const frameworkComponent: angular.IComponentOptions;
}
declare namespace Osgi {
    const frameworkModule: string;
}
declare namespace Osgi {
    class OsgiController {
        private workspace;
        tabs: Nav.HawtioTab[];
        constructor(workspace: Jmx.Workspace);
        $onInit(): void;
    }
    const osgiComponent: angular.IComponentOptions;
}
declare namespace Osgi {
    class OsgiDataService {
        private jolokia;
        private workspace;
        constructor(workspace: Jmx.Workspace, jolokia: any);
        getBundles(): {};
        getServices(): {};
        getPackages(): {};
    }
}
declare namespace Osgi {
    const _module: angular.IModule;
}
declare namespace Quartz {
    const log: Logging.Logger;
    const jmxDomain = "quartz";
    function configureRoutes($routeProvider: angular.route.IRouteProvider): void;
    function configureLayout(mainNavService: Nav.MainNavService, workspace: Jmx.Workspace): void;
    function configureHelp(helpRegistry: Help.HelpRegistry, workspace: Jmx.Workspace): void;
    function iconClass(state: any): string;
    function misfireText(val: number): string;
}
declare namespace Quartz {
    class QuartzNavController {
        private $location;
        tabs: Nav.HawtioTab[];
        constructor($location: ng.ILocationService);
        $onInit(): void;
        goto(tab: Nav.HawtioTab): void;
    }
    const quartzComponent: angular.IComponentOptions;
}
declare namespace Quartz {
    type OnSuccessFn = (response: Jolokia.IResponse | string[]) => void;
    type OnErrorFn = (response: Jolokia.IErrorResponse) => void;
    export class QuartzService {
        private jolokia;
        private workspace;
        constructor(jolokia: Jolokia.IJolokia, workspace: Jmx.Workspace);
        getQuartzMBean(): string;
        private getMBeanTypeFolder;
        searchSchedulers(onSuccess: OnSuccessFn): void;
        readSchedulerName(mbean: string): string;
        registerRead(scope: ng.IScope, mbean: string, onSuccess: OnSuccessFn): void;
        unregister(scope: ng.IScope): void;
        getTriggerState(mbean: string, args: any[]): {
            value: string;
        };
        start(mbean: string, onSuccess: OnSuccessFn): void;
        standby(mbean: string, onSuccess: OnSuccessFn): void;
        private execute;
        canPauseTrigger(mbean: string): boolean;
        pauseTrigger(mbean: string, args: string[], onSuccess: OnSuccessFn): void;
        canResumeTrigger(mbean: string): boolean;
        resumeTrigger(mbean: string, args: string[], onSuccess: OnSuccessFn): void;
        canUpdateTrigger(_mbean: string): boolean;
        updateCronTrigger(args: any[], onSuccess: OnSuccessFn, onError?: OnErrorFn): void;
        updateSimpleTrigger(args: any[], onSuccess: OnSuccessFn, onError?: OnErrorFn): void;
        canManualTrigger(mbean: string): boolean;
        triggerJob(mbean: string, args: string[], onSuccess: OnSuccessFn, onError?: OnErrorFn): void;
        private executeWithArgs;
        enableSampledStatistics(mbean: string): void;
        disableSampledStatistics(mbean: string): void;
        private setAttribute;
        private canExecuteOperation;
    }
    export {};
}
declare namespace Quartz {
    class TreeController {
        private $scope;
        private $location;
        private workspace;
        private quartzService;
        constructor($scope: ng.IScope, $location: ng.ILocationService, workspace: Jmx.Workspace, quartzService: QuartzService);
        $onInit(): void;
        private reloadTree;
        private createQuartzSchedulerFolder;
        private addChildScheduler;
        private updateSelectionFromURL;
    }
    const treeComponent: angular.IComponentOptions;
}
declare namespace Quartz {
    const treeModule: string;
    const treeElementId = "#quartztree";
}
declare namespace Quartz {
    interface Trigger {
        id: string;
        group: string;
        name: string;
        state: string;
        type: string;
        jobGroup: string;
        jobName: string;
        expression: string;
        cron: string;
        misfireInstruction: number;
        previousFireTime: Date;
        nextFireTime: Date;
        finalFireTime: Date;
        repeatCount: number;
        repeatInterval: number;
    }
    interface UpdateTriggerForm {
        group: string;
        name: string;
        type: string;
        cron: string;
        misfireInstruction: string;
        repeatCount: number;
        repeatInterval: number;
        showCron: boolean;
        showRepeatCount: boolean;
        showRepeatInterval: boolean;
        misfireInstructions: {
            id: string;
            title: string;
        }[];
    }
    interface ManualTriggerForm {
        name: string;
        group: string;
        parameters: string;
    }
}
declare namespace Quartz {
    interface Job {
        id: string;
        group: string;
        name: string;
        durability: boolean;
        shouldRecover: boolean;
        jobClass: string;
        description: string;
        jobDataMap: {
            [key: string]: string;
        };
    }
}
declare namespace Quartz {
    interface Scheduler {
        AllJobDetails: {
            [key: string]: Job;
        };
        AllTriggers: Trigger[];
        SchedulerName: string;
        JobGroupNames: string[];
    }
}
declare namespace Quartz {
    type Filter = {
        id: string;
        title: string;
        value: string;
    };
    class QuartzController {
        protected $scope: ng.IScope;
        protected $location: ng.ILocationService;
        protected quartzService: QuartzService;
        constructor($scope: ng.IScope, $location: ng.ILocationService, quartzService: QuartzService);
        selectedSchedulerMBean: string;
        selectedScheduler: Scheduler;
        triggers: Trigger[];
        jobs: Job[];
        $onInit(): void;
        protected clear(): void;
        private selectionChanged;
        private renderQuartz;
        protected updateSelectedScheduler(): void;
        /**
         * Grabs state for a trigger which requires to call a JMX operation
         */
        private updateTriggerState;
        protected onTriggersUpdated(): void;
        protected onJobsUpdated(): void;
    }
}
declare namespace Quartz {
    class SchedulerController extends QuartzController {
        pauseScheduler(): void;
        startScheduler(): void;
        enableSampleStatistics(): void;
        disableSampleStatistics(): void;
    }
    const schedulerComponent: angular.IComponentOptions;
}
declare namespace Quartz {
    const schedulerModule: string;
}
declare namespace Quartz {
    class TriggerController extends QuartzController {
        $onInit(): void;
        protected clear(): void;
        protected onTriggersUpdated(): void;
        filteredTriggers: Trigger[];
        private readonly filterFields;
        private readonly filterConfig;
        private applyFilters;
        readonly toolbarConfig: {
            filterConfig: {
                fields: ({
                    id: string;
                    title: string;
                    placeholder: string;
                    filterType: string;
                    filterValues: string[];
                } | {
                    id: string;
                    title: string;
                    placeholder: string;
                    filterType: string;
                    filterValues?: undefined;
                })[];
                resultsCount: number;
                totalCount: number;
                appliedFilters: any[];
                onFilterChange: (filters: Filter[]) => void;
            };
            actionsConfig: {};
            isTableView: boolean;
        };
        readonly tableConfig: {
            selectionMatchProp: string;
            showCheckboxes: boolean;
        };
        readonly tableColumns: ({
            header: string;
            itemField: string;
            templateFn: (value: string) => string;
        } | {
            header: string;
            itemField: string;
            templateFn?: undefined;
        } | {
            header: string;
            itemField: string;
            templateFn: (value: number) => string;
        })[];
        private readonly resumePauseAction;
        private readonly updateAction;
        private readonly manualTriggerAction;
        actionButtons: any[];
        menuActions: any[];
        private configureActions;
        pauseTrigger(trigger: Trigger): void;
        resumeTrigger(trigger: Trigger): void;
        showUpdateTriggerDialog: boolean;
        updateTriggerTitle: string;
        readonly updateTriggerTemplate = "plugins/quartz/triggers/triggers-update-dialog.html";
        updateTriggerForm: UpdateTriggerForm;
        readonly updateTriggerButtons: ({
            label: string;
            isCancel: boolean;
            class?: undefined;
            actionFn?: undefined;
        } | {
            label: string;
            class: string;
            actionFn: () => void;
            isCancel?: undefined;
        })[];
        private readonly misfireInstructions;
        beforeUpdateTrigger(trigger: Trigger): void;
        onUpdateTrigger(): void;
        showManualTriggerDialog: boolean;
        readonly manualTriggerTitle = "Manually fire trigger";
        readonly manualTriggerTemplate = "plugins/quartz/triggers/triggers-manual-dialog.html";
        manualTriggerForm: ManualTriggerForm;
        readonly manualTriggerButtons: ({
            label: string;
            isCancel: boolean;
            class?: undefined;
            actionFn?: undefined;
        } | {
            label: string;
            class: string;
            actionFn: () => void;
            isCancel?: undefined;
        })[];
        beforeManualTrigger(trigger: Trigger): void;
        onManualTrigger(): void;
        onClose(): void;
    }
    const triggersComponent: angular.IComponentOptions;
}
declare namespace Quartz {
    const triggersModule: string;
}
declare namespace Quartz {
    class JobsController extends QuartzController {
        protected onJobsUpdated(): void;
        filteredJobs: Job[];
        private readonly filterFields;
        private readonly filterConfig;
        private applyFilters;
        readonly toolbarConfig: {
            filterConfig: {
                fields: ({
                    id: string;
                    title: string;
                    placeholder: string;
                    filterType: string;
                    filterValues?: undefined;
                } | {
                    id: string;
                    title: string;
                    placeholder: string;
                    filterType: string;
                    filterValues: string[];
                })[];
                resultsCount: number;
                totalCount: number;
                appliedFilters: any[];
                onFilterChange: (filters: Filter[]) => void;
            };
            isTableView: boolean;
        };
        readonly tableConfig: {
            selectionMatchProp: string;
            showCheckboxes: boolean;
        };
        readonly tableColumns: {
            header: string;
            itemField: string;
        }[];
        showJobDetails: boolean;
        jobDetailsTitle: string;
        readonly jobDetailsTemplate = "plugins/quartz/jobs/jobs-details-dialog.html";
        jobDetailsScope: {
            dataMap: {
                [key: string]: string;
            };
            keys: string[];
        };
        readonly jobDetailsButtons: {
            label: string;
        }[];
        onClick(job: Job): void;
        onClose(): void;
    }
    const jobsComponent: angular.IComponentOptions;
}
declare namespace Quartz {
    const jobsModule: string;
}
declare namespace Quartz {
    const quartzModule: string;
}
declare namespace SpringBoot {
    class Health {
        global: HealthCard;
        details: HealthCard[];
        constructor(global: HealthCard, details: HealthCard[]);
    }
    interface HealthCard {
        title: string;
        iconClass: string;
        info?: string[];
    }
}
declare namespace SpringBoot {
    interface EndpointMBean {
        objectName: string;
        operation: string;
    }
}
declare namespace SpringBoot {
    class HealthService {
        private jolokiaService;
        private humanizeService;
        private springBootService;
        constructor(jolokiaService: JVM.JolokiaService, humanizeService: Core.HumanizeService, springBootService: SpringBootService);
        getHealth(): ng.IPromise<Health>;
        private getGlobalCard;
        private getDetailCards;
        private buildInfo;
        getIconClass(status: string): "pficon pficon-ok" | "pficon pficon-error-circle-o" | "pficon pficon-warning-triangle-o" | "pficon pficon-help" | "pficon pficon-info";
        private sortByFirstValue;
    }
}
declare namespace SpringBoot {
    class HealthController {
        private $interval;
        private healthService;
        readonly reloadDelay = 20000;
        reloadTask: ng.IPromise<any>;
        health: Health;
        constructor($interval: ng.IIntervalService, healthService: HealthService);
        $onInit(): void;
        $onDestroy(): void;
        loadDataPeriodically(): void;
        loadData(): void;
        cancelReloadTask(): void;
    }
    const healthComponent: angular.IComponentOptions;
}
declare namespace SpringBoot {
    const healthModule: string;
}
declare namespace SpringBoot {
    type Item = {
        key: string;
        value: any;
    };
    export class Info {
        items: Item[];
        constructor(obj: any);
        private flatten;
        private prefixKey;
    }
    export {};
}
declare namespace SpringBoot {
    class InfoService {
        private jolokiaService;
        private springBootService;
        constructor(jolokiaService: JVM.JolokiaService, springBootService: SpringBootService);
        getInfo(): ng.IPromise<Info>;
    }
}
declare namespace SpringBoot {
    class InfoController {
        private $interval;
        private infoService;
        private readonly reloadDelay;
        private reloadTask;
        info: Info;
        constructor($interval: ng.IIntervalService, infoService: InfoService);
        $onInit(): void;
        $onDestroy(): void;
        loadDataPeriodically(): void;
        loadData(): void;
        cancelReloadTask(): void;
    }
    const infoComponent: angular.IComponentOptions;
}
declare namespace SpringBoot {
    const infoModule: string;
}
declare namespace SpringBoot {
    class Trace {
        timestamp: string;
        method: string;
        path: string;
        httpStatusCode: number;
        timeTaken: number;
        info: any;
        constructor(trace: any);
    }
}
declare namespace SpringBoot {
    class TraceService {
        private jolokiaService;
        private springBootService;
        constructor(jolokiaService: JVM.JolokiaService, springBootService: SpringBootService);
        getTraces(): ng.IPromise<Trace[]>;
    }
}
declare namespace SpringBoot {
    class TraceController {
        private traceService;
        private $scope;
        private $filter;
        private $timeout;
        private $interval;
        private $uibModal;
        private static CACHE_SIZE;
        private toolbarConfig;
        loading: boolean;
        traces: Trace[];
        tableItems: Trace[];
        selectedTrace: Trace;
        promise: ng.IPromise<any>;
        dateFormat: string;
        constructor(traceService: TraceService, $scope: any, $filter: ng.IFilterService, $timeout: ng.ITimeoutService, $interval: ng.IIntervalService, $uibModal: any);
        $onInit(): void;
        $onDestroy(): void;
        loadTraces(): void;
        applyFilters(filters: any[]): void;
        getStatusClass(trace: Trace): string;
        openTraceModal(trace: Trace): void;
        private aggregateTraces;
        private scrollIfRequired;
    }
    const traceComponent: angular.IComponentOptions;
}
declare namespace SpringBoot {
    const traceModule: string;
}
declare namespace SpringBoot {
    interface LoggerConfiguration {
        levels: string[];
        loggers: Logger[];
    }
    interface Logger {
        name: string;
        configuredLevel: string;
        effectiveLevel: string;
    }
}
declare namespace SpringBoot {
    class LoggersService {
        private jolokiaService;
        private springBootService;
        constructor(jolokiaService: JVM.JolokiaService, springBootService: SpringBootService);
        getLoggerConfiguration(): ng.IPromise<LoggerConfiguration>;
        setLoggerLevel(logger: Logger): ng.IPromise<void>;
    }
}
declare namespace SpringBoot {
    class LoggersController {
        private loggersService;
        private filterFields;
        private filterConfig;
        private toolbarConfig;
        private pageSize;
        private pageNumber;
        private numTotalItems;
        loading: boolean;
        loggers: Logger[];
        tableItems: Logger[];
        loggerLevels: string[];
        constructor(loggersService: LoggersService);
        $onInit(): void;
        loadData(): void;
        setLoggerLevel(logger: Logger): void;
        applyFilters(filters: any[]): void;
        private orderLoggers;
    }
    const loggersComponent: angular.IComponentOptions;
}
declare namespace SpringBoot {
    const loggersModule: string;
}
declare namespace SpringBoot {
    class SpringBootService {
        private workspace;
        constructor(workspace: Jmx.Workspace);
        getTabs(): Nav.HawtioTab[];
        getEndpointMBean(endpoints: string[], operations: string[]): EndpointMBean;
        isValid(): boolean;
        private hasEndpoint;
    }
}
declare namespace SpringBoot {
    function configureRoutes($routeProvider: angular.route.IRouteProvider): void;
    function configureLayout(workspace: Jmx.Workspace, springBootService: SpringBootService, mainNavService: Nav.MainNavService): void;
    function configureHelp(helpRegistry: Help.HelpRegistry, springBootService: SpringBootService): void;
}
declare namespace SpringBoot {
    class SpringBootController {
        private springBootService;
        tabs: Nav.HawtioTab[];
        constructor(springBootService: SpringBootService);
        $onInit(): void;
    }
    const springBootComponent: angular.IComponentOptions;
}
declare namespace SpringBoot {
    const springBootModule: string;
    const log: Logging.Logger;
}
declare namespace Integration {
    const integrationModule: string;
}
declare namespace ActiveMQ {
    var BrowseQueueController: angular.IModule;
}
declare namespace ActiveMQ {
}
declare namespace ActiveMQ {
}
declare namespace ActiveMQ {
}
declare namespace ActiveMQ {
}
declare namespace Camel {
    var BrowseEndpointController: angular.IModule;
}
declare namespace Camel {
    var camelHeaderSchema: {
        definitions: {
            headers: {
                properties: {
                    "CamelAuthentication": {
                        type: string;
                    };
                    "CamelAuthenticationFailurePolicyId": {
                        type: string;
                    };
                    "CamelAcceptContentType": {
                        type: string;
                    };
                    "CamelAggregatedSize": {
                        type: string;
                    };
                    "CamelAggregatedTimeout": {
                        type: string;
                    };
                    "CamelAggregatedCompletedBy": {
                        type: string;
                    };
                    "CamelAggregatedCorrelationKey": {
                        type: string;
                    };
                    "CamelAggregationStrategy": {
                        type: string;
                    };
                    "CamelAggregationCompleteAllGroups": {
                        type: string;
                    };
                    "CamelAggregationCompleteAllGroupsInclusive": {
                        type: string;
                    };
                    "CamelAsyncWait": {
                        type: string;
                    };
                    "CamelBatchIndex": {
                        type: string;
                    };
                    "CamelBatchSize": {
                        type: string;
                    };
                    "CamelBatchComplete": {
                        type: string;
                    };
                    "CamelBeanMethodName": {
                        type: string;
                    };
                    "CamelBeanMultiParameterArray": {
                        type: string;
                    };
                    "CamelBinding": {
                        type: string;
                    };
                    "breadcrumbId": {
                        type: string;
                    };
                    "CamelCharsetName": {
                        type: string;
                    };
                    "CamelCreatedTimestamp": {
                        type: string;
                    };
                    "Content-Encoding": {
                        type: string;
                    };
                    "Content-Length": {
                        type: string;
                    };
                    "Content-Type": {
                        type: string;
                    };
                    "CamelCorrelationId": {
                        type: string;
                    };
                    "CamelDataSetIndex": {
                        type: string;
                    };
                    "org.apache.camel.default.charset": {
                        type: string;
                    };
                    "CamelDestinationOverrideUrl": {
                        type: string;
                    };
                    "CamelDisableHttpStreamCache": {
                        type: string;
                    };
                    "CamelDuplicateMessage": {
                        type: string;
                    };
                    "CamelExceptionCaught": {
                        type: string;
                    };
                    "CamelExceptionHandled": {
                        type: string;
                    };
                    "CamelEvaluateExpressionResult": {
                        type: string;
                    };
                    "CamelErrorHandlerHandled": {
                        type: string;
                    };
                    "CamelExternalRedelivered": {
                        type: string;
                    };
                    "CamelFailureHandled": {
                        type: string;
                    };
                    "CamelFailureEndpoint": {
                        type: string;
                    };
                    "CamelFailureRouteId": {
                        type: string;
                    };
                    "CamelFilterNonXmlChars": {
                        type: string;
                    };
                    "CamelFileLocalWorkPath": {
                        type: string;
                    };
                    "CamelFileName": {
                        type: string;
                    };
                    "CamelFileNameOnly": {
                        type: string;
                    };
                    "CamelFileNameProduced": {
                        type: string;
                    };
                    "CamelFileNameConsumed": {
                        type: string;
                    };
                    "CamelFilePath": {
                        type: string;
                    };
                    "CamelFileParent": {
                        type: string;
                    };
                    "CamelFileLastModified": {
                        type: string;
                    };
                    "CamelFileLength": {
                        type: string;
                    };
                    "CamelFilterMatched": {
                        type: string;
                    };
                    "CamelFileLockFileAcquired": {
                        type: string;
                    };
                    "CamelFileLockFileName": {
                        type: string;
                    };
                    "CamelGroupedExchange": {
                        type: string;
                    };
                    "CamelHttpBaseUri": {
                        type: string;
                    };
                    "CamelHttpCharacterEncoding": {
                        type: string;
                    };
                    "CamelHttpMethod": {
                        type: string;
                    };
                    "CamelHttpPath": {
                        type: string;
                    };
                    "CamelHttpProtocolVersion": {
                        type: string;
                    };
                    "CamelHttpQuery": {
                        type: string;
                    };
                    "CamelHttpResponseCode": {
                        type: string;
                    };
                    "CamelHttpUri": {
                        type: string;
                    };
                    "CamelHttpUrl": {
                        type: string;
                    };
                    "CamelHttpChunked": {
                        type: string;
                    };
                    "CamelHttpServletRequest": {
                        type: string;
                    };
                    "CamelHttpServletResponse": {
                        type: string;
                    };
                    "CamelInterceptedEndpoint": {
                        type: string;
                    };
                    "CamelInterceptSendToEndpointWhenMatched": {
                        type: string;
                    };
                    "CamelLanguageScript": {
                        type: string;
                    };
                    "CamelLogDebugBodyMaxChars": {
                        type: string;
                    };
                    "CamelLogDebugStreams": {
                        type: string;
                    };
                    "CamelLoopIndex": {
                        type: string;
                    };
                    "CamelLoopSize": {
                        type: string;
                    };
                    "CamelMaximumCachePoolSize": {
                        type: string;
                    };
                    "CamelMaximumEndpointCacheSize": {
                        type: string;
                    };
                    "CamelMessageHistory": {
                        type: string;
                    };
                    "CamelMulticastIndex": {
                        type: string;
                    };
                    "CamelMulticastComplete": {
                        type: string;
                    };
                    "CamelNotifyEvent": {
                        type: string;
                    };
                    "CamelOnCompletion": {
                        type: string;
                    };
                    "CamelOverruleFileName": {
                        type: string;
                    };
                    "CamelParentUnitOfWork": {
                        type: string;
                    };
                    "CamelRecipientListEndpoint": {
                        type: string;
                    };
                    "CamelReceivedTimestamp": {
                        type: string;
                    };
                    "CamelRedelivered": {
                        type: string;
                    };
                    "CamelRedeliveryCounter": {
                        type: string;
                    };
                    "CamelRedeliveryMaxCounter": {
                        type: string;
                    };
                    "CamelRedeliveryExhausted": {
                        type: string;
                    };
                    "CamelRedeliveryDelay": {
                        type: string;
                    };
                    "CamelRollbackOnly": {
                        type: string;
                    };
                    "CamelRollbackOnlyLast": {
                        type: string;
                    };
                    "CamelRouteStop": {
                        type: string;
                    };
                    "CamelSoapAction": {
                        type: string;
                    };
                    "CamelSkipGzipEncoding": {
                        type: string;
                    };
                    "CamelSlipEndpoint": {
                        type: string;
                    };
                    "CamelSplitIndex": {
                        type: string;
                    };
                    "CamelSplitComplete": {
                        type: string;
                    };
                    "CamelSplitSize": {
                        type: string;
                    };
                    "CamelTimerCounter": {
                        type: string;
                    };
                    "CamelTimerFiredTime": {
                        type: string;
                    };
                    "CamelTimerName": {
                        type: string;
                    };
                    "CamelTimerPeriod": {
                        type: string;
                    };
                    "CamelTimerTime": {
                        type: string;
                    };
                    "CamelToEndpoint": {
                        type: string;
                    };
                    "CamelTraceEvent": {
                        type: string;
                    };
                    "CamelTraceEventNodeId": {
                        type: string;
                    };
                    "CamelTraceEventTimestamp": {
                        type: string;
                    };
                    "CamelTraceEventExchange": {
                        type: string;
                    };
                    "Transfer-Encoding": {
                        type: string;
                    };
                    "CamelUnitOfWorkExhausted": {
                        type: string;
                    };
                    "CamelUnitOfWorkProcessSync": {
                        type: string;
                    };
                    "CamelXsltFileName": {
                        type: string;
                    };
                };
            };
        };
    };
}
declare namespace Camel {
}
declare namespace Camel {
    var jmsHeaderSchema: {
        definitions: {
            headers: {
                properties: {
                    JMSCorrelationID: {
                        type: string;
                    };
                    JMSDeliveryMode: {
                        "type": string;
                        "enum": string[];
                    };
                    JMSDestination: {
                        type: string;
                    };
                    JMSExpiration: {
                        type: string;
                    };
                    JMSPriority: {
                        type: string;
                    };
                    JMSReplyTo: {
                        type: string;
                    };
                    JMSType: {
                        type: string;
                    };
                    JMSXGroupId: {
                        type: string;
                    };
                    AMQ_SCHEDULED_CRON: {
                        type: string;
                    };
                    AMQ_SCHEDULED_DELAY: {
                        type: string;
                    };
                    AMQ_SCHEDULED_PERIOD: {
                        type: string;
                    };
                    AMQ_SCHEDULED_REPEAT: {
                        type: string;
                    };
                };
            };
            "javax.jms.Destination": {
                type: string;
            };
        };
    };
}
declare namespace Camel {
}
declare namespace Camel {
}
declare namespace Camel {
}
declare namespace Camel {
}
declare namespace Camel {
}
declare namespace Camel {
}
declare namespace Camel {
    class ConditionalBreakpoint {
        nodeId: string;
        language: string;
        predicate: string;
    }
}
/**
 * @module DataTable
 * @main DataTable
 */
declare namespace DataTable {
    const pluginName: string;
    const log: Logging.Logger;
    const _module: angular.IModule;
}
/**
 * @module DataTable
 */
declare namespace DataTable {
}
/**
 * Module that contains several helper functions related to hawtio's code editor
 *
 * @module CodeEditor
 * @main CodeEditor
 */
declare namespace CodeEditor {
    /**
     * Options for the CodeMirror text editor
     *
     * @class CodeMirrorOptions
     */
    interface CodeMirrorOptions {
        /**
         * @property theme
         * @type String
         */
        theme: string;
        /**
         * @property tabSize
         * @type number
         */
        tabSize: number;
        /**
         * @property lineNumbers
         * @type boolean
         */
        lineNumbers: boolean;
        /**
         * @property indentWithTabs
         * @type boolean
         */
        indentWithTabs: boolean;
        /**
         * @property lineWrapping
         * @type boolean
         */
        lineWrapping: boolean;
        /**
         * @property autoClosetags
         * @type boolean
         */
        autoClosetags: boolean;
    }
    /**
     * @property GlobalCodeMirrorOptions
     * @for CodeEditor
     * @type CodeMirrorOptions
     */
    var GlobalCodeMirrorOptions: {
        theme: string;
        tabSize: number;
        lineNumbers: boolean;
        indentWithTabs: boolean;
        lineWrapping: boolean;
        autoCloseTags: boolean;
    };
    /**
     * Tries to figure out what kind of text we're going to render in the editor, either
     * text, javascript or XML.
     *
     * @method detectTextFormat
     * @for CodeEditor
     * @static
     * @param value
     * @returns {string}
     */
    function detectTextFormat(value: any): string;
    /**
     * Auto formats the CodeMirror editor content to pretty print
     *
     * @method autoFormatEditor
     * @for CodeEditor
     * @static
     * @param {CodeMirrorEditor} editor
     * @return {void}
     */
    function autoFormatEditor(editor: CodeMirrorEditor): void;
    /**
     * Used to configures the default editor settings (per Editor Instance)
     *
     * @method createEditorSettings
     * @for CodeEditor
     * @static
     * @param {Object} options
     * @return {Object}
     */
    function createEditorSettings(options?: any): any;
}
declare namespace HawtioEditor {
    const pluginName: string;
    const templatePath: string;
    const log: Logging.Logger;
}
declare namespace HawtioEditor {
    var _module: angular.IModule;
}
/**
 * @module HawtioEditor
 */
declare namespace HawtioEditor {
    function Editor($parse: any): {
        restrict: string;
        replace: boolean;
        templateUrl: string;
        scope: {
            text: string;
            mode: string;
            readOnly: string;
            outputEditor: string;
            name: string;
        };
        controller: (string | (($scope: any, $element: any, $attrs: any) => void))[];
        link: ($scope: any, $element: any, $attrs: any) => void;
    };
}
/**
 * @module Forms
 */
declare namespace Forms {
    /**
     * Default any values in the schema on the entity if they are not already present
     * @method defaultValues
     * @param {any} entity
     * @param {any} schema
     */
    function defaultValues(entity: any, schema: any): void;
    /**
     * If the type name refers to an alias in the schemas definitions then perform the lookup and return the real type name
     * @method resolveTypeNAmeAlias
     * @param {String} type
     * @param {any} schema
     *
     */
    function resolveTypeNameAlias(type: any, schema: any): any;
    /**
     * Walks the base class hierarchy checking if the given type is an instance of the given type name
     * @method isJsonType
     * @param {String} name
     * @param {any} schema
     * @param {String} typeName
     * @return {Boolean}
     */
    function isJsonType(name: any, schema: any, typeName: any): boolean;
    /**
     * Removes any dodgy characters for a valid identifier in angularjs such as for '-' characters
     * which are replaced with '_'
     * @method safeIdentifier
     * @param {String} id
     * @return {String}
     */
    function safeIdentifier(id: string): string;
    /**
     * Looks up the given type name in the schemas definitions
     * @method lookupDefinition
     * @param {String} name
     * @param {any} schema
     */
    function lookupDefinition(name: any, schema: any): any;
    /**
     * For an array property, find the schema of the items which is either nested inside this property
     * in the 'items' property; or the type name is used to lookup in the schemas definitions
     * @method findArrayItemsSchema
     * @param {String} property
     * @param {any} schema
     */
    function findArrayItemsSchema(property: any, schema: any): any;
    /**
     * Returns true if the given schema definition is an object
     * @method isObjectType
     * @param {any} definition
     */
    function isObjectType(definition: any): boolean;
    /**
     * Returns true if the given property represents a nested object or array of objects
     * @method isArrayOrNestedObject
     * @param {any} property
     * @param {any} schema
     */
    function isArrayOrNestedObject(property: any, schema: any): boolean;
    function configure(config: any, scopeConfig: any, attrs: any): any;
    function getControlGroup(config: any, arg: any, id: any): JQLite;
    function getLabel(config: any, arg: any, label: any, required?: boolean): JQLite;
    function getControlDiv(config: any): JQLite;
    function getHelpSpan(config: any, arg: any, id: any, property?: any): JQLite;
}
/**
 * @module Forms
 */
declare namespace Forms {
    /**
     * Create a DOM widget tree for the given set of form configuration data.
     *
     * This will include either the standard AngularJS widgets or custom widgets
     */
    function createWidget(propTypeName: any, property: any, schema: any, config: any, id: any, ignorePrefixInLabel: any, configScopeName: any, wrapInGroup?: boolean, disableHumanizeLabel?: boolean): JQuery;
    /**
     * Lets try create the standard angular JS widgets markup
     * @method createStandardWidgetMarkup
     * @param {String} propTypeName
     * @param {any} property
     * @param {any} schema
     * @param {any} config
     * @param {any} options
     * @param {String} id
     */
    function createStandardWidgetMarkup(propTypeName: any, property: any, schema: any, config: any, options: any, id: any): string;
    function mapType(type: String): String;
    function normalize(type: any, property: any, schema: any): "hawtio-form-text" | "hawtio-form-custom" | "hawtio-form-select" | "hawtio-form-number" | "hawtio-form-string-array" | "hawtio-form-array" | "hawtio-form-checkbox" | "hawtio-form-password" | "hawtio-form-hidden" | "hawtio-form-map";
}
/**
 * @module Forms
 */
declare namespace Forms {
    /**
     * @class InputBaseConfig
      */
    class InputBaseConfig {
        name: string;
        type: string;
        description: string;
        _default: string;
        scope: any;
        mode: string;
        schemaName: string;
        controlgroupclass: string;
        controlclass: string;
        labelclass: string;
        showtypes: string;
        /**
         * Custom template for custom form controls
         * @property
         * @type String
         */
        formtemplate: any;
        /**
         * the name of the attribute in the scope which is the data to be edited
         * @property
         * @type String
         */
        entity: string;
        /**
         * the model expression to bind to. If omitted this defaults to entity + "." + name
         * @property
         * @type String
         */
        model: any;
        getEntity(): string;
        getMode(): string;
        isReadOnly(): boolean;
    }
    class InputBase {
        $compile: any;
        restrict: string;
        scope: boolean;
        replace: boolean;
        transclude: boolean;
        private attributeName;
        link: (scope: any, element: any, attrs: any) => any;
        constructor($compile: any);
        doLink(scope: any, element: any, attrs: any): void;
        getControlGroup(config1: any, config2: any, id: any): any;
        getInput(config: any, arg: any, id: any, modelName: any): JQLite;
    }
    class TextInput extends InputBase {
        $compile: any;
        type: string;
        constructor($compile: any);
        getInput(config: any, arg: any, id: any, modelName: any): JQLite;
    }
    class HiddenText extends TextInput {
        $compile: any;
        type: string;
        constructor($compile: any);
        getControlGroup(config1: any, config2: any, id: any): any;
        getInput(config: any, arg: any, id: any, modelName: any): JQLite;
    }
    class PasswordInput extends TextInput {
        $compile: any;
        type: string;
        constructor($compile: any);
    }
    class CustomInput extends InputBase {
        $compile: any;
        constructor($compile: any);
        getInput(config: any, arg: any, id: any, modelName: any): JQLite;
    }
    class SelectInput extends InputBase {
        $compile: any;
        constructor($compile: any);
        getInput(config: any, arg: any, id: any, modelName: any): JQLite;
    }
    class NumberInput extends InputBase {
        $compile: any;
        constructor($compile: any);
        getInput(config: any, arg: any, id: any, modelName: any): JQLite;
        private onModelChange;
    }
    /**
     * Generates a list of strings which can be added / edited / removed
     * @class StringArrayInput
     */
    class StringArrayInput extends InputBase {
        $compile: any;
        constructor($compile: any);
        getInput(config: any, arg: any, id: any, modelName: any): JQLite;
        private updateKeys;
    }
    class ArrayInput extends InputBase {
        $compile: any;
        constructor($compile: any);
        doLink(scope: any, element: any, attrs: any): void;
    }
    class BooleanInput extends InputBase {
        $compile: any;
        constructor($compile: any);
        getInput(config: any, arg: any, id: any, modelName: any): JQLite;
        private onModelChange;
    }
}
declare namespace Forms {
    const pluginName = "hawtio-forms";
    const templateUrl = "plugins/components/forms/html/";
    const log: Logging.Logger;
}
declare namespace Forms {
    class SimpleFormConfig {
        name: string;
        method: string;
        entity: string;
        schemaName: string;
        mode: string;
        data: any;
        json: any;
        scope: any;
        scopeName: string;
        properties: any[];
        action: string;
        formclass: string;
        controlgroupclass: string;
        controlclass: string;
        labelclass: string;
        showtypes: string;
        showhelp: string;
        showempty: string;
        onsubmit: string;
        getMode(): string;
        getEntity(): string;
        isReadOnly(): boolean;
    }
    class SimpleForm {
        $compile: any;
        restrict: string;
        scope: boolean;
        replace: boolean;
        transclude: boolean;
        private attributeName;
        link: (scope: any, element: any, attrs: any) => any;
        constructor($compile: any);
        isReadOnly(): boolean;
        private doLink;
        private createForm;
        private getLegend;
    }
}
declare namespace Forms {
    class InputTableConfig {
        name: string;
        method: string;
        entity: string;
        tableConfig: string;
        mode: string;
        data: any;
        json: any;
        properties: any[];
        action: string;
        tableclass: string;
        controlgroupclass: string;
        controlclass: string;
        labelclass: string;
        showtypes: string;
        removeicon: string;
        editicon: string;
        addicon: string;
        removetext: string;
        edittext: string;
        addtext: string;
        onadd: string;
        onedit: string;
        onremove: string;
        primaryKeyProperty: any;
        getTableConfig(): string;
    }
    class InputTable {
        $compile: any;
        restrict: string;
        scope: boolean;
        replace: boolean;
        transclude: boolean;
        private attributeName;
        link: (scope: any, element: any, attrs: any) => any;
        constructor($compile: any);
        private doLink;
        private getAddButton;
        private getEditButton;
        private getRemoveButton;
        private createTable;
        private getLegend;
        private getControlGroup;
        private getControlDiv;
        private getHelpSpan;
    }
}
declare namespace Forms {
    class SubmitForm {
        restrict: string;
        scope: boolean;
        link: (scope: any, element: any, attrs: any) => any;
        constructor();
        private doLink;
    }
}
declare namespace Forms {
    class ResetForm {
        restrict: string;
        scope: boolean;
        link: (scope: any, element: any, attrs: any) => any;
        constructor();
        private doLink;
    }
}
declare namespace Forms {
    var _module: angular.IModule;
}
declare namespace Forms {
    /**
     * Map of name/value pairs that get mapped to element attributes
     */
    interface AttributeMap {
        [key: string]: string;
    }
    /**
     * Element in a FormConfiguration's 'properties' attribute
     */
    interface FormElement {
        type: string;
        tooltip?: string;
        label?: string;
        hidden?: boolean;
        'input-attributes'?: AttributeMap;
        'control-group-attributes'?: AttributeMap;
        formTemplate?: string;
    }
    /**
     * Factory method to create a FormElement object
     * @returns {FormElement}
     */
    function createFormElement(): FormElement;
    /**
     * Type for the FormConfiguration's 'properties' attribute
     */
    interface FormProperties {
        [name: string]: FormElement;
    }
    /**
     * Type for the FormConfiguration's 'tabs' attribute
     */
    interface FormTabs {
        [name: string]: Array<string>;
    }
    /**
     * Factory method to create a FormTabs object
     * @returns {FormTabs}
     */
    function createFormTabs(): FormTabs;
    /**
     * Interface that describes the configuration object for hawtio forms
     */
    interface FormConfiguration {
        id?: string;
        type?: string;
        disableHumanizeLabel?: boolean;
        ignorePrefixInLabel?: boolean;
        properties: FormProperties;
        tabs?: FormTabs;
    }
    /**
     * Factory method to create a FormConfiguration object
     * @returns {FormConfiguration}
     */
    function createFormConfiguration(): FormConfiguration;
    interface FormGridElement extends FormElement {
        key?: string;
        headerTemplate: string;
        template: string;
    }
    interface FormGridProperties {
        [name: string]: FormGridElement;
    }
    interface FormGridRowConfiguration extends FormConfiguration {
        properties: FormGridProperties;
        columnOrder: Array<string>;
    }
    interface FormGridConfiguration {
        heading?: boolean;
        rowName?: string;
        rowSchema: FormGridRowConfiguration;
        rows: Array<any>;
        onAdd: () => any;
        noDataTemplate: string;
    }
    function createFormGridConfiguration(): FormGridConfiguration;
    interface HawtioFormScope extends ng.IScope {
        addItem: any;
        deleteKey: any;
        entity: any;
        name: any;
        newItem: any;
        showForm: any;
    }
}
declare namespace Forms {
}
declare namespace Forms {
}
declare namespace HawtioForms {
    interface AttributeMap {
        [key: string]: string;
    }
    interface FormSelectors {
        [key: string]: (el: any) => void;
    }
    /**
     * Element in a FormConfiguration's 'properties' attribute
     */
    interface FormElement {
        type: string;
        tooltip?: string;
        label?: string;
        hidden?: boolean;
        javaType?: string;
        value?: any;
        default?: any;
        enum?: any;
        items?: any;
        'input-attributes'?: AttributeMap;
        'control-group-attributes'?: AttributeMap;
        'label-attributes'?: AttributeMap;
        formTemplate?: string;
        selectors?: FormSelectors;
        [key: string]: any;
    }
    /**
     * Type for the FormConfiguration's 'properties' attribute
     */
    interface FormProperties {
        [name: string]: FormElement;
    }
    /**
     * Type for the FormConfiguration's 'tabs' attribute
     */
    interface FormTabs {
        [name: string]: Array<string>;
    }
    /**
     * Enum for form mode attribute
     */
    enum FormMode {
        VIEW = 0,
        EDIT = 1
    }
    /**
     * Enum for the overall form style
     */
    enum FormStyle {
        STANDARD = 0,
        INLINE = 1,
        HORIZONTAL = 2,
        UNWRAPPED = 3
    }
    interface FormWizardPage {
        title?: string;
        controls: Array<string>;
    }
    interface FormWizardPages {
        pages: FormWizardPage;
    }
    /**
     * Interface that describes the configuration object for hawtio forms
     */
    interface FormConfiguration {
        id?: string;
        type?: string;
        mode?: FormMode;
        style?: FormStyle;
        disableHumanizeLabel?: boolean;
        ignorePrefixInLabel?: boolean;
        properties: FormProperties;
        tabs?: FormTabs;
        wizard?: FormWizardPages;
        controls?: Array<string>;
        label?: string;
        debug?: boolean;
        [key: string]: any;
    }
    function createFormConfiguration(options?: FormConfiguration): FormConfiguration;
    interface ControlMappingRegistry {
        hasMapping(name: string): boolean;
        addMapping(name: string, controlType: string): any;
        getMapping(name: string): string;
        removeMapping(name: string): string;
        iterate(iter: (controlType: string, name: string) => void): any;
    }
    interface SchemaRegistry {
        addSchema(name: string, schema: FormConfiguration): any;
        getSchema(name: string): FormConfiguration;
        cloneSchema(name: string): FormConfiguration;
        removeSchema(name: string): FormConfiguration;
        iterate(iter: (FormConfiguration: any, string: any) => void): any;
        addListener(name: string, callback: (nme: string, schema: any) => void): any;
        removeListener(name: string): any;
    }
    interface HawtioFormScope extends ng.IScope {
        entity: any;
        config: any;
        keySchema: any;
        valueSchema: any;
        editRow: any;
        deleteRow: any;
        createRow: any;
        diff: any;
        configChanges: any;
        name: any;
        maybeHumanize: any;
        pageIds: any;
        onFinish: any;
        buttons: any;
        isValid: any;
        isDisabled: any;
        isBackDisabled: any;
        currentPageIndex: any;
        gotoPage: any;
        onCancel: any;
        onChange: any;
        getCurrentPageId: any;
        atFront: any;
        atBack: any;
        next: any;
        back: any;
        createNewRow: any;
        watch: any;
    }
}
declare namespace HawtioForms {
    var pluginName: string;
    var templatePath: string;
    var log: Logging.Logger;
    class Constants {
        static readonly FORM_STANDARD: string;
        static readonly FORM_INLINE: string;
        static readonly FORM_UNWRAPPED: string;
        static readonly FORM_HORIZONTAL: string;
        static readonly STANDARD_HORIZONTAL_INPUT: string;
        static readonly STANDARD_INPUT: string;
        static readonly STATIC_HORIZONTAL_TEXT: string;
        static readonly STATIC_TEXT: string;
        static readonly SELECT_HORIZONTAL: string;
        static readonly SELECT: string;
        static readonly OPTION_ARRAY: string;
        static readonly OPTION_OBJECT: string;
        static readonly OPTION_CONFIG_OBJECT: string;
        static readonly CHECKBOX_HORIZONTAL: string;
        static readonly CHECKBOX: string;
        static readonly OBJECT: string;
        static readonly ARRAY: string;
        static readonly MAP: string;
        static readonly HIDDEN: string;
    }
    function addPostInterpolateAction(context: any, name: any, func: (el: any) => any): void;
    function addPreCompileAction(context: any, name: any, func: () => void): void;
    function getFormMain(context: any, config: FormConfiguration): string;
    function getStandardTemplate(context: any, config: FormConfiguration, control: FormElement, type: string): string;
    function applyElementConfig(context: any, config: FormConfiguration, control: FormElement, template: string, type?: string): string;
    function getStaticTextTemplate(context: any, config: FormConfiguration): string;
    function setSelectOptions(isArray: boolean, propName: string, select: any): void;
    function getSelectTemplate(context: any, config: FormConfiguration, name: string, control: FormElement): string;
    function getCheckboxTemplate(context: any, config: FormConfiguration, control: FormElement): string;
    function getObjectTemplate(context: any, config: FormConfiguration, name: string, control: FormElement): string;
    function getMapTemplate(context: any, config: FormConfiguration, name: string, control: FormElement): string;
    function getArrayTemplate(context: any, config: FormConfiguration, name: string, control: FormElement): string;
    function lookupTemplate(context: any, config: FormConfiguration, name: string, control: FormElement): string;
    function getTemplate(context: any, config: FormConfiguration, name: any, control: FormElement): string;
    function interpolateTemplate(context: any, config: FormConfiguration, name: any, control: FormElement, template: string, model: string): string;
    function createMaybeHumanize(context: any): (value: any) => any;
    function initConfig(context: any, config: FormConfiguration, lookup?: boolean): FormConfiguration;
}
declare namespace HawtioForms {
    var _module: angular.IModule;
}
declare namespace HawtioForms {
}
declare namespace HawtioForms {
}
declare var diffString: any;
declare namespace HawtioForms {
}
declare namespace HawtioForms {
}
declare namespace HawtioForms {
}
declare namespace HawtioForms {
}
declare namespace Toastr {
}
declare namespace Core {
    /**
     * Displays an alert message which is typically the result of some asynchronous operation
     *
     * @method notification
     * @static
     * @param type which is usually "success", "info", "warning", or "danger" (for error) and matches css alert-* css styles
     * @param message the text to display
     * @param duration number of milliseconds the notification is visible
     *
     */
    function notification(type: string, message: string, duration?: number): void;
    /**
     * Clears all the pending notifications
     * @method clearNotifications
     * @static
     */
    function clearNotifications(): void;
}
declare namespace UI {
    const pluginName: string;
    const log: Logging.Logger;
    const templatePath: string;
}
/**
 * Module that contains a bunch of re-usable directives to assemble into pages in hawtio
 *
 * @module UI
 * @main UI
 */
declare namespace UI {
    var _module: angular.IModule;
}
/**
 * @module UI
 */
declare namespace UI {
}
declare namespace UI {
}
declare namespace UI {
}
/**
 * @module UI
 */
declare namespace UI {
    /**
     * Configuration object for the ConfirmDialog directive
     * @class ConfirmDialogConfig
     */
    interface ConfirmDialogConfig extends ng.IScope {
        /**
         * Model used to open/close the dialog
         *
         * @property hawtioConfirmDialog
         * @type String
         */
        show: string;
        /**
         * Sets the title of the dialog
         *
         * @property title
         * @type String
         */
        title: string;
        /**
         * Sets the text used on the dialogs "OK" button
         *
         * @property okButtonText
         * @type String
         */
        okButtonText: string;
        /**
         * Whether to show the ok button
         *
         * @property showOkButton
         * @type boolean
         */
        showOkButton: string;
        /**
         * Sets the text used on the dialog's "Cancel" button
         *
         * @property cancelButtonText
         * @type String
         */
        cancelButtonText: string;
        /**
         * callback function that's called when the dialog has been cancelled
         *
         * @property onCancel
         * @type String
         */
        onCancel: string;
        /**
         * Callback function that's called when the user has clicked "OK"
         *
         * @property onOk
         * @type String
         */
        onOk: string;
        /**
         * Callback function when the dialog has been closed either way
         *
         * @property onClose
         * @type String
         */
        onClose: string;
        /**
         * Alternative size: 'sm', 'lg'
         *
         * @property size
         * @type string
         */
        size: string;
        /**
         * @deprecated Use 'size'
         */
        optionalSize: string;
    }
    /**
     * Directive that opens a simple standard confirmation dialog.  See ConfigDialogConfig
     * for configuration properties
     *
     * @class ConfirmDialog
     */
    class ConfirmDialog {
        restrict: string;
        replace: boolean;
        transclude: boolean;
        templateUrl: string;
        /**
         * @property scope
         * @type ConfirmDialogConfig
         */
        scope: {
            show: string;
            title: string;
            okButtonText: string;
            showOkButton: string;
            cancelButtonText: string;
            onCancel: string;
            onOk: string;
            onClose: string;
            size: string;
            optionalSize: string;
        };
        controller: (string | (($scope: any, $element: JQuery, $attrs: angular.IAttributes, $transclude: any, $compile: any) => void))[];
        constructor();
    }
}
/**
 * @module UI
 */
declare namespace UI {
}
/**
 * @module UI
 */
declare namespace UI {
    /**
     * Simple helper class for creating <a href="http://angular-ui.github.io/bootstrap/#/modal">angular ui bootstrap modal dialogs</a>
     * @class Dialog
     */
    class Dialog {
        show: boolean;
        options: {
            backdropFade: boolean;
            dialogFade: boolean;
        };
        /**
         * Opens the dialog
         * @method open
         */
        open(): void;
        /**
         * Closes the dialog
         * @method close
         */
        close(): void;
        removeBackdropFadeDiv(): void;
    }
    interface MultiItemConfirmActionOptions {
        collection: Array<any>;
        index: string;
        onClose: (result: boolean) => void;
        action: string;
        okText?: string;
        cancelText?: string;
        title?: string;
        custom?: string;
        okClass?: string;
        cancelClass?: string;
        customClass?: string;
    }
    function multiItemConfirmActionDialog(options: MultiItemConfirmActionOptions): any;
}
declare namespace UI {
    var hawtioDrag: angular.IModule;
    var hawtioDrop: angular.IModule;
}
/**
 * @module UI
 */
declare namespace UI {
    class EditableProperty {
        private $parse;
        restrict: string;
        scope: boolean;
        templateUrl: string;
        require: string;
        link: any;
        constructor($parse: any);
    }
}
declare namespace UI {
}
/**
 * @module UI
 */
declare namespace UI {
    var hawtioFilter: angular.IModule;
}
/**
 * @module UI
 */
declare namespace UI {
    class GridsterDirective {
        restrict: string;
        replace: boolean;
        controller: (string | (($scope: any, $element: any, $attrs: any) => void))[];
        link: ($scope: any, $element: any, $attrs: any) => void;
    }
}
declare namespace UI {
    function groupBy(): (list: any, group: any) => any;
}
declare namespace UI {
}
/**
 * @module UI
 */
declare namespace UI {
    function hawtioList($templateCache: any, $compile: any): {
        restrict: string;
        replace: boolean;
        templateUrl: string;
        scope: {
            'config': string;
        };
        link: ($scope: any, $element: any, $attr: any) => void;
    };
}
declare namespace UI {
}
/**
 * @module UI
 */
declare namespace UI {
    function hawtioPane(): {
        restrict: string;
        replace: boolean;
        transclude: boolean;
        templateUrl: string;
        scope: {
            position: string;
            width: string;
            header: string;
        };
        controller: (string | (($scope: any, $element: any, $attrs: any, $transclude: any, $document: any, $timeout: any, $compile: any, $templateCache: any, $window: any) => void))[];
        link: ($scope: any, $element: any, $attr: any) => void;
    };
}
/**
 * @module UI
 */
declare namespace UI {
    class MessagePanel {
        restrict: string;
        link: ($scope: any, $element: any, $attrs: any) => void;
    }
    class InfoPanel {
        restrict: string;
        link: ($scope: any, $element: any, $attrs: any) => void;
    }
}
/**
 * @module UI
 */
declare namespace UI {
    class DivRow {
        restrict: string;
        link: ($scope: any, $element: any, $attrs: any) => void;
    }
}
/**
 * @module UI
 */
declare namespace UI {
    class TablePager {
        restrict: string;
        scope: boolean;
        templateUrl: string;
        link: (scope: any, element: any, attrs: any) => any;
        $scope: any;
        element: any;
        attrs: any;
        tableName: string;
        setRowIndexName: string;
        rowIndexName: string;
        constructor();
        private doLink;
        tableData(): any;
        goToIndex(idx: number): void;
    }
}
/**
 * @module UI
 */
declare namespace UI {
    function TemplatePopover($templateCache: any, $compile: any, $document: any): {
        restrict: string;
        link: ($scope: any, $element: any, $attr: any) => void;
    };
}
/**
 * @module UI
 */
declare namespace UI {
    function HawtioTocDisplay(marked: any, $location: any, $anchorScroll: any, $compile: any): {
        restrict: string;
        scope: {
            getContents: string;
        };
        controller: (string | (($scope: any, $element: any, $attrs: any) => void))[];
        link: ($scope: any, $element: any, $attrs: any) => void;
    };
}
/**
 * @module UI
 */
declare namespace UI {
    class ViewportHeight {
        restrict: string;
        link: ($scope: any, $element: any, $attrs: any) => void;
    }
    class HorizontalViewport {
        restrict: string;
        link: ($scope: any, $element: any, $attrs: any) => void;
    }
}
declare namespace UI {
}
declare namespace UIBootstrap {
}
declare namespace Diagnostics {
    interface JvmFlag {
        name: string;
        value: any;
        writeable: boolean;
        origin: string;
        deregisterWatch: any;
        dataType: string;
    }
    interface JvmFlagsScope extends ng.IScope {
        flags: Array<JvmFlag>;
        tableDef: any;
    }
    function DiagnosticsFlagsController($scope: JvmFlagsScope, jolokia: Jolokia.IJolokia): void;
}
declare namespace JVM {
    const rootPath = "plugins/jvm";
    const templatePath: string;
    const pluginName = "hawtio-jmx-jvm";
    const log: Logging.Logger;
    const connectionSettingsKey = "jvmConnect";
    const logoPath = "img/icons/jvm/";
    const logoRegistry: {
        'jetty': string;
        'tomcat': string;
        'generic': string;
    };
    const proxyEnabledPath = "proxy/enabled";
    let proxyEnabled: boolean;
}
declare namespace JVM {
    /**
     * Adds common properties and functions to the scope
     * @method configureScope
     * @for Jvm
     * @param {*} $scope
     * @param {ng.ILocationService} $location
     * @param {Core.Workspace} workspace
     */
    function configureScope($scope: any, $location: any, workspace: any): void;
    function hasLocalMBean(workspace: any): any;
    function hasDiscoveryMBean(workspace: any): any;
    /**
     * Creates a jolokia object for connecting to the container with the given remote jolokia URL,
     * username and password
     * @method createJolokia
     * @for Core
     * @static
     * @param {String} url
     * @param {String} username
     * @param {String} password
     * @return {Object}
     */
    function createJolokia(url: string, username: string, password: string): Jolokia.IJolokia;
    function getRecentConnections(localStorage: any): any;
    function addRecentConnection(localStorage: any, name: any): void;
    function removeRecentConnection(localStorage: any, name: any): void;
    function clearConnections(): void;
    function isRemoteConnection(): boolean;
    function connectToServer(localStorage: any, options: ConnectOptions): void;
    function saveConnection(options: ConnectOptions): void;
    /**
     * Loads all of the available connections from local storage
     */
    function loadConnections(): ConnectOptions[];
    /**
     * Saves the connection map to local storage
     * @param connections array of all connections to be stored
     */
    function saveConnections(connections: ConnectOptions[]): void;
    function getConnectionNameParameter(): any;
    /**
     * Returns the connection options for the given connection name from localStorage
     */
    function getConnectOptions(name: string, localStorage?: WindowLocalStorage): ConnectOptions;
    /**
     * Creates the Jolokia URL string for the given connection options
     */
    function createServerConnectionUrl(options: ConnectOptions): string;
}
declare namespace JVM {
    type JolokiaFactory = (options: ConnectOptions, checkCredentials?: boolean) => Jolokia.IJolokia;
    class ConnectService {
        private $q;
        private $window;
        private $location;
        constructor($q: ng.IQService, $window: ng.IWindowService, $location: ng.ILocationService);
        private _createJolokia;
        createJolokia: JolokiaFactory;
        getConnections(): ConnectOptions[];
        updateReachableFlags(connections: ConnectOptions[]): ng.IPromise<ConnectOptions[]>;
        updateReachableFlag(connection: ConnectOptions): ng.IPromise<ConnectOptions>;
        saveConnections(connections: ConnectOptions[]): void;
        importConnections(connections: ConnectOptions[]): void;
        testConnection(connection: ConnectOptions): ng.IPromise<ConnectionTestResult>;
        checkCredentials(connection: ConnectOptions, username: string, password: string): ng.IPromise<boolean>;
        connect(connection: ConnectOptions): void;
        getDefaultOptions(): ConnectOptions;
        private getBrowserUrlPortNumber;
        private getBrowserUrlContextPath;
        private forbiddenReasonMatches;
    }
}
declare namespace JVM {
    const connectComponent: angular.IComponentOptions;
}
declare namespace JVM {
    class ConnectEditModalController {
        private connectService;
        modalInstance: any;
        operation: 'add' | 'edit';
        resolve: {
            connection: ConnectOptions;
            connectionNames: string[];
        };
        connection: ConnectOptions;
        errors: {};
        connectionTestResult: ConnectionTestResult;
        connectionNames: string[];
        constructor(connectService: ConnectService);
        $onInit(): void;
        testConnection(connection: ConnectOptions): void;
        cancel(): void;
        saveConnection(connection: any): void;
        private validateConnection;
    }
    const connectEditModalComponent: angular.IComponentOptions;
}
declare namespace JVM {
    const connectDeleteModalComponent: angular.IComponentOptions;
}
declare namespace JVM {
    class ConnectImportController {
        private $timeout;
        private connectService;
        close: Function;
        input: HTMLInputElement;
        fileSelected: boolean;
        updateFileSelectedFlag: () => void;
        errorMessage: string;
        constructor($timeout: ng.ITimeoutService, connectService: ConnectService);
        $onInit(): void;
        $onDestroy(): void;
        import(): void;
    }
    const connectImportModalComponent: angular.IComponentOptions;
}
declare namespace JVM {
    class ConnectLoginController {
        private $location;
        private $window;
        private $uibModal;
        private userDetails;
        private postLoginTasks;
        private postLogoutTasks;
        constructor($location: ng.ILocationService, $window: ng.IWindowService, $uibModal: angular.ui.bootstrap.IModalService, userDetails: Core.AuthService, postLoginTasks: Core.Tasks, postLogoutTasks: Core.Tasks);
        $onInit(): void;
        private registerTaskToPersistCredentials;
    }
    const connectLoginComponent: angular.IComponentOptions;
}
declare namespace JVM {
    class ConnectLoginModalController {
        private ConnectOptions;
        private connectService;
        modalInstance: any;
        invalidCredentials: boolean;
        constructor(ConnectOptions: ConnectOptions, connectService: ConnectService);
        cancel(): void;
        login(username: string, password: string): void;
    }
    const connectLoginModalComponent: angular.IComponentOptions;
}
declare namespace JVM {
    const connectUnreachableModalComponent: angular.IComponentOptions;
}
declare namespace JVM {
    function ConnectionUrlFilter(): (connection: ConnectOptions) => string;
}
declare namespace JVM {
    const connectModule: string;
}
declare namespace JVM {
    function createJolokiaParams(jolokiaUrl: string, localStorage: Storage): Jolokia.IParams;
}
declare namespace JVM {
    function JolokiaPreferences($scope: any, localStorage: any, jolokiaParams: any, $window: any): void;
}
declare namespace JVM {
    const jolokiaModule: string;
}
declare namespace JVM {
    class JvmController {
        tabs: Nav.HawtioTab[];
        constructor(workspace: Jmx.Workspace);
    }
    const jvmComponent: angular.IComponentOptions;
}
declare namespace JVM {
    const _module: angular.IModule;
}
declare namespace JVM {
    enum JolokiaListMethod {
        LIST_GENERAL = "list",
        LIST_OPTIMISED = "list_optimised",
        LIST_CANT_DETERMINE = "cant_determine"
    }
    const DEFAULT_MAX_DEPTH = 7;
    const DEFAULT_MAX_COLLECTION_SIZE = 50000;
    let ConnectionName: string;
    function getConnectionName(reset?: boolean): string;
    function getJolokiaUrl(): string | boolean;
    interface JolokiaStatus {
        xhr: JQueryXHR;
        listMethod: JolokiaListMethod;
        listMBean: string;
    }
    /**
     * Empty jolokia that returns nothing
     */
    class DummyJolokia implements Jolokia.IJolokia {
        isDummy: boolean;
        private running;
        request(...args: any[]): any;
        getAttribute(mbean: any, attribute: any, path?: any, opts?: any): any;
        setAttribute(mbean: any, attribute: any, value: any, path?: any, opts?: any): void;
        execute(mbean: any, operation: any, ...args: any[]): any;
        search(mBeanPatter: any, opts?: any): any;
        list(path: any, opts?: any): any;
        version(opts?: any): any;
        register(params: any, ...request: any[]): any;
        unregister(handle: any): void;
        jobs(): any[];
        start(period: any): void;
        stop(): void;
        isRunning(): boolean;
    }
    interface ConnectOptions {
        name?: string;
        scheme?: string;
        host?: string;
        port?: number;
        path?: string;
        useProxy?: boolean;
        jolokiaUrl?: string;
        userName?: string;
        password?: string;
        reachable?: boolean;
        returnTo?: string;
    }
    function createConnectOptions(options?: ConnectOptions): ConnectOptions;
}
declare namespace Jmx {
    enum TreeEvent {
        Fetched = "jmxTreeFetched",
        Updated = "jmxTreeUpdated",
        NodeSelected = "jmxTreeClicked"
    }
}
declare namespace Core {
    function scopeStoreJolokiaHandle($scope: any, jolokia: any, jolokiaHandle: any): void;
    function closeHandle($scope: any, jolokia: any): void;
    /**
     * Pass in null for the success function to switch to sync mode
     *
     * @method onSuccess
     * @static
     * @param {Function} Success callback function
     * @param {Object} Options object to pass on to Jolokia request
     * @return {Object} initialized options object
     */
    function onSuccess(fn: (response: Jolokia.IResponse) => void | ((response: Jolokia.IResponse) => void)[], options?: Jolokia.IParams): any;
    /**
     * The default error handler which logs errors either using debug or log level logging based on the silent setting
     * @param response the response from a jolokia request
     */
    function defaultJolokiaErrorHandler(response: Jolokia.IErrorResponse, options?: Jolokia.IParams): void;
    /**
     * Logs any failed operation and stack traces
     */
    function logJolokiaStackTrace(response: Jolokia.IErrorResponse): void;
    /**
     * Escapes the mbean for Jolokia GET requests.
     *
     * @param {string} mbean the mbean
     * @returns {string}
     */
    function escapeMBean(mbean: string): string;
    /**
     * Escapes the mbean as a path for Jolokia POST "list" requests.
     * See: https://jolokia.org/reference/html/protocol.html#list
     *
     * @param {string} mbean the mbean
     * @returns {string}
     */
    function escapeMBeanPath(mbean: string): string;
    function parseMBean(mbean: any): any;
    /**
     * Register a JMX operation to poll for changes, only
     * calls back when a change occurs
     *
     * @param jolokia
     * @param scope
     * @param arguments
     * @param callback
     * @param options
     * @returns Object
     */
    function registerForChanges(jolokia: any, $scope: any, arguments: any, callback: (response: any) => void, options?: any): () => void;
    interface IResponseHistory {
        [name: string]: any;
    }
    function getOrInitObjectFromLocalStorage(key: string): any;
    function getResponseHistory(): any;
    const MAX_RESPONSE_CACHE_SIZE = 20;
    /**
     * Register a JMX operation to poll for changes
     * @method register
     * @for Core
     * @static
     * @return {Function} a zero argument function for unregistering  this registration
     * @param {*} jolokia
     * @param {*} scope
     * @param {Object} arguments
     * @param {Function} callback
     */
    function register(jolokia: Jolokia.IJolokia, scope: any, arguments: any, callback: any): () => void;
    /**
     * Register a JMX operation to poll for changes using a jolokia search using the given mbean pattern
     * @method registerSearch
     * @for Core
     * @static
     * @paran {*} jolokia
     * @param {*} scope
     * @param {String} mbeanPattern
     * @param {Function} callback
     */
    function unregister(jolokia: Jolokia.IJolokia, scope: any): void;
    /**
     * Reorder paths when they aren't in the correct order.
     * @param {object[]} paths
     * @param {string} domainText
     */
    function reorderPathsIfRequired(domainText: string, paths: object[]): void;
}
declare namespace Jmx {
    /**
     * @class NavMenuItem
     */
    interface NavMenuItem {
        id: string;
        content: string;
        title?: string;
        isValid?(workspace: Workspace, perspectiveId?: string): any;
        isActive?(worksace: Workspace): boolean;
        href(): any;
    }
    /**
     * @class Workspace
     */
    class Workspace {
        jolokia: Jolokia.IJolokia;
        jolokiaStatus: JVM.JolokiaStatus;
        jmxTreeLazyLoadRegistry: any;
        $location: ng.ILocationService;
        $compile: ng.ICompileService;
        $templateCache: ng.ITemplateCacheService;
        localStorage: Storage;
        $rootScope: ng.IRootScopeService;
        operationCounter: number;
        selection: NodeSelection;
        tree: Folder;
        mbeanTypesToDomain: {};
        mbeanServicesToDomain: {};
        attributeColumnDefs: {};
        onClickRowHandlers: {};
        treePostProcessors: {
            [name: string]: (tree: Folder) => void;
        };
        topLevelTabs: any;
        subLevelTabs: any[];
        keyToNodeMap: {};
        pluginRegisterHandle: any;
        pluginUpdateCounter: any;
        treeWatchRegisterHandle: any;
        treeWatcherCounter: any;
        treeFetched: boolean;
        mapData: {};
        constructor(jolokia: Jolokia.IJolokia, jolokiaStatus: JVM.JolokiaStatus, jmxTreeLazyLoadRegistry: any, $location: ng.ILocationService, $compile: ng.ICompileService, $templateCache: ng.ITemplateCacheService, localStorage: Storage, $rootScope: ng.IRootScopeService);
        /**
         * Creates a shallow copy child workspace with its own selection and location
         * @method createChildWorkspace
         * @param {ng.ILocationService} location
         * @return {Workspace}
         */
        createChildWorkspace(location: any): Workspace;
        getLocalStorage(key: string): any;
        setLocalStorage(key: string, value: any): void;
        private jolokiaList;
        loadTree(): void;
        /**
         * Adds a post processor of the tree to swizzle the tree metadata after loading
         * such as correcting any typeName values or CSS styles by hand
         */
        addNamedTreePostProcessor(name: string, processor: (tree: Folder) => void): string;
        removeNamedTreePostProcessor(name: string): void;
        maybeMonitorPlugins(): void;
        maybeUpdatePlugins(response: Jolokia.IResponse): void;
        maybeReloadTree(response: Jolokia.IResponse): void;
        /**
         * Processes response from jolokia list - if it contains "domains" and "cache" properties
         * @param response
         */
        unwindResponseWithRBACCache(response: any): Core.JMXDomains;
        populateTree(response: {
            value: Core.JMXDomains;
        }): void;
        setTreeFetched(): void;
        jmxTreeUpdated(): void;
        private populateDomainFolder;
        /**
         * Escape only '<' and '>' as opposed to Core.escapeHtml() and _.escape()
         *
         * @param {string} str string to be escaped
        */
        private escapeTagOnly;
        private populateMBeanFolder;
        private splitMBeanProperty;
        private initFolder;
        configureFolder(folder: Folder, domainName: string, domainClass: string, folderNames: string[], path: string): void;
        private addFolderByDomain;
        private enableLazyLoading;
        /**
         * Returns the hash query argument to append to URL links
         * @method hash
         * @return {String}
         */
        hash(): string;
        /**
         * Returns the currently active tab
         * @method getActiveTab
         * @return {Boolean}
         */
        getActiveTab(): any;
        private getStrippedPathName;
        linkContains(...words: String[]): boolean;
        /**
         * Returns true if the given link is active. The link can omit the leading # or / if necessary.
         * The query parameters of the URL are ignored in the comparison.
         * @method isLinkActive
         * @param {String} href
         * @return {Boolean} true if the given link is active
         */
        isLinkActive(href: string): boolean;
        /**
         * Returns true if the given link is active. The link can omit the leading # or / if necessary.
         * The query parameters of the URL are ignored in the comparison.
         * @method isLinkActive
         * @param {String} href
         * @return {Boolean} true if the given link is active
         */
        isLinkPrefixActive(href: string): boolean;
        /**
         * Returns true if the tab query parameter is active or the URL starts with the given path
         * @method isTopTabActive
         * @param {String} path
         * @return {Boolean}
         */
        isTopTabActive(path: string): boolean;
        isMainTabActive(path: string): boolean;
        /**
         * Returns the selected mbean name if there is one
         * @method getSelectedMBeanName
         * @return {String}
         */
        getSelectedMBeanName(): string;
        getSelectedMBean(): NodeSelection;
        /**
         * Returns true if the path is valid for the current selection
         * @method validSelection
         * @param {String} uri
         * @return {Boolean}
         */
        validSelection(uri: string): boolean;
        /**
         * In cases where we have just deleted something we typically want to change
         * the selection to the parent node
         * @method removeAndSelectParentNode
         */
        removeAndSelectParentNode(): void;
        selectParentNode(): void;
        /**
         * Returns the view configuration key for the kind of selection
         * for example based on the domain and the node type
         * @method selectionViewConfigKey
         * @return {String}
         */
        selectionViewConfigKey(): string;
        /**
         * Returns a configuration key for a node which is usually of the form
         * domain/typeName or for folders with no type, domain/name/folder
         * @method selectionConfigKey
         * @param {String} prefix
         * @return {String}
         */
        selectionConfigKey(prefix?: string): string;
        moveIfViewInvalid(): boolean;
        updateSelectionNode(node: NodeSelection): void;
        broadcastSelectionNode(): void;
        private matchesProperties;
        hasInvokeRightsForName(objectName: string, ...methods: string[]): boolean;
        hasInvokeRights(selection: NodeSelection, ...methods: string[]): boolean;
        /**
         * Returns true only if all relevant operations can be invoked.
         */
        private resolveCanInvokeInOps;
        private resolveCanInvoke;
        treeContainsDomainAndProperties(domainName: string, properties?: any): boolean;
        private matches;
        hasDomainAndProperties(domainName: string, properties?: any, propertiesCount?: any): boolean;
        findMBeanWithProperties(domainName: string, properties?: any, propertiesCount?: any): any;
        findChildMBeanWithProperties(folder: any, properties?: any, propertiesCount?: any): any;
        selectionHasDomainAndLastFolderName(objectName: string, lastName: string): boolean;
        selectionHasDomain(domainName: string): boolean;
        selectionHasDomainAndType(objectName: string, typeName: string): boolean;
        /**
         * Returns true if this workspace has any mbeans at all
         */
        hasMBeans(): boolean;
        hasFabricMBean(): boolean;
        isFabricFolder(): boolean;
        isCamelContext(): boolean;
        isCamelFolder(): boolean;
        isEndpointsFolder(): boolean;
        isEndpoint(): boolean;
        isRoutesFolder(): boolean;
        isRoute(): boolean;
        isComponentsFolder(): boolean;
        isComponent(): boolean;
        isDataformatsFolder(): boolean;
        isDataformat(): boolean;
        isOsgiFolder(): boolean;
        isKarafFolder(): boolean;
        isOsgiCompendiumFolder(): boolean;
    }
}
declare namespace Jmx {
    class TreeService {
        private $rootScope;
        private $q;
        private workspace;
        constructor($rootScope: ng.IRootScopeService, $q: ng.IQService, workspace: Jmx.Workspace);
        treeContainsDomainAndProperties(domainName: string, properties?: any): ng.IPromise<boolean>;
        findMBeanWithProperties(domainName: string, properties?: any, propertiesCount?: any): ng.IPromise<any>;
        getSelectedMBean(): ng.IPromise<NodeSelection>;
        getSelectedMBeanName(): ng.IPromise<string>;
        runWhenTreeReady(fn: () => any): ng.IPromise<any>;
        private runWhenTreeSelectionReady;
    }
}
declare namespace Diagnostics {
    class DiagnosticsService {
        private workspace;
        private configManager;
        constructor(workspace: Jmx.Workspace, configManager: Core.ConfigManager);
        getTabs(): Nav.HawtioTab[];
        private hasHotspotDiagnostic;
        private hasDiagnosticFunction;
        flightRecorderMBean(): string;
    }
}
declare namespace Diagnostics {
    interface ClassStats {
        count: string;
        bytes: string;
        name: string;
        deltaCount: string;
        deltaBytes: string;
    }
    interface HeapControllerScope extends ng.IScope {
        items: Array<ClassStats>;
        loading: boolean;
        lastLoaded: any;
        toolbarConfig: any;
        tableConfig: any;
        tableDtOptions: any;
        tableColumns: Array<any>;
        pageConfig: object;
        loadClassStats: () => void;
    }
    function DiagnosticsHeapController($scope: HeapControllerScope, jolokia: Jolokia.IJolokia, diagnosticsService: DiagnosticsService): void;
}
declare namespace Diagnostics {
    interface JfrSettings {
        limitType: string;
        limitValue: string;
        recordingNumber: string;
        dumpOnExit: boolean;
        name: string;
        filename: string;
        configuration: string;
    }
    interface Recording {
        number: string;
        size: string;
        file: string;
        time: number;
        canDownload: boolean;
        downloadLink: string;
    }
    interface RecordingFromJfrBean {
        destination: string;
        maxSize: number;
        duration: number;
        size: number;
        maxAge: number;
        toDisk: boolean;
        name: string;
        startTime: number;
        stopTime: number;
        id: number;
        state: string;
        dumpOnExit: boolean;
        settings: Map<string, string>;
    }
    interface JfrControllerScope extends ng.IScope {
        forms: any;
        jfrEnabled: boolean;
        isRecording: boolean;
        isRunning: boolean;
        jfrSettings: JfrSettings;
        unlock: () => void;
        startRecording: () => void;
        stopRecording: () => void;
        dumpRecording: () => void;
        formConfig: Forms.FormConfiguration;
        recordings: Array<Recording>;
        pid: string;
        jfrStatus: string;
        pageTitle: string;
        settingsVisible: boolean;
        toggleSettingsVisible: () => void;
        jcmd: string;
        closeMessageForGood: (key: string) => void;
        isMessageVisible: (key: string) => boolean;
        configurations: Array<string>;
    }
    function DiagnosticsJfrController($scope: JfrControllerScope, $location: ng.ILocationService, workspace: Jmx.Workspace, jolokia: Jolokia.IJolokia, localStorage: Storage, diagnosticsService: DiagnosticsService, jolokiaUrl: string): void;
}
declare namespace Diagnostics {
    class DiagnosticsController {
        private diagnosticsService;
        tabs: Nav.HawtioTab[];
        constructor(diagnosticsService: DiagnosticsService);
        $onInit(): void;
    }
    const diagnosticsComponent: angular.IComponentOptions;
}
declare namespace Diagnostics {
    function configureRoutes($routeProvider: angular.route.IRouteProvider): void;
    function configureHelp(helpRegistry: Help.HelpRegistry): void;
    function configureMainNav(mainNavService: Nav.MainNavService, diagnosticsService: DiagnosticsService): void;
}
declare namespace Diagnostics {
    const log: Logging.Logger;
    const _module: angular.IModule;
}
declare namespace Jmx {
    const jmxComponent: angular.IComponentOptions;
}
declare namespace Jmx {
    let currentProcessId: string;
    function configureRoutes($routeProvider: ng.route.IRouteProvider): void;
    function configureHelp(helpRegistry: any): void;
    function configureMainNav(mainNavService: Nav.MainNavService, workspace: Workspace): void;
    function configurePageTitle(pageTitle: any, jolokia: any): void;
    function initializeTree($q: ng.IQService, $rootScope: ng.IRootScopeService, initService: Init.InitService, workspace: Workspace): void;
}
declare namespace Jmx {
    function AttributesController($scope: any, $location: ng.ILocationService, workspace: Workspace, localStorage: Storage, $uibModal: angular.ui.bootstrap.IModalService, attributesService: AttributesService): void;
}
/**
 * @namespace RBAC
 */
declare namespace RBAC {
    interface RBACTasks extends Core.Tasks {
        initialize(mbean: string): void;
        getACLMBean(): ng.IPromise<string>;
    }
    interface OperationCanInvoke {
        CanInvoke: boolean;
        Method: string;
        ObjectName: string;
    }
}
declare namespace Jmx {
    class AttributesService {
        private $q;
        private jolokia;
        private jolokiaUrl;
        private rbacACLMBean;
        constructor($q: ng.IQService, jolokia: Jolokia.IJolokia, jolokiaUrl: string, rbacACLMBean: ng.IPromise<string>);
        registerJolokia(scope: any, request: any, callback: any): void;
        unregisterJolokia(scope: any): void;
        listMBean(mbeanName: string, callback: any): void;
        canInvoke(mbeanName: string, attribute: string, type: string): ng.IPromise<boolean>;
        buildJolokiaUrl(mbeanName: string, attribute: string): string;
        update(mbeanName: string, attribute: string, value: any): void;
    }
}
declare namespace Jmx {
    const attributesModule: string;
}
declare namespace Jmx {
    class HeaderController {
        title: string;
        objectName: string;
        constructor($scope: any);
    }
    const headerComponent: angular.IComponentOptions;
}
declare namespace Jmx {
    class NavigationController {
        private $location;
        private workspace;
        tabs: Nav.HawtioTab[];
        constructor($scope: ng.IScope, $location: ng.ILocationService, workspace: Jmx.Workspace);
        $onInit(): void;
        private getTabs;
        goto(tab: Nav.HawtioTab): void;
    }
    const navigationComponent: angular.IComponentOptions;
}
declare namespace Jmx {
    const commonModule: string;
}
declare namespace Jmx {
    class Operation {
        args: OperationArgument[];
        description: string;
        name: string;
        readableName: string;
        canInvoke: boolean;
        constructor(method: string, args: OperationArgument[], description: string);
        private static buildName;
        private static buildReadableName;
    }
    class OperationArgument {
        name: string;
        type: string;
        desc: string;
        constructor();
        readableType(): string;
    }
}
declare namespace Jmx {
    class OperationsService {
        private $q;
        private jolokia;
        private jolokiaUrl;
        private workspace;
        private treeService;
        private rbacACLMBean;
        constructor($q: ng.IQService, jolokia: Jolokia.IJolokia, jolokiaUrl: string, workspace: Jmx.Workspace, treeService: TreeService, rbacACLMBean: ng.IPromise<string>);
        getOperations(): ng.IPromise<Operation[]>;
        private fetchOperations;
        private addOperation;
        private fetchPermissions;
        executeOperation(mbeanName: string, operation: Operation, argValues?: any[]): ng.IPromise<string>;
        buildJolokiaUrl(operation: Operation): string;
    }
}
declare namespace Jmx {
    class OperationsController {
        private operationsService;
        operations: Operation[];
        config: {
            showSelectBox: boolean;
            useExpandingRows: boolean;
        };
        menuActions: {
            name: string;
            actionFn: (action: any, item: Operation) => void;
        }[];
        constructor(operationsService: OperationsService);
        $onInit(): void;
    }
    const operationsComponent: angular.IComponentOptions;
}
declare namespace Jmx {
    class OperationFormController {
        private workspace;
        private operationsService;
        operation: Operation;
        formFields: {
            label: string;
            type: string;
            helpText: string;
            value: any;
        }[];
        editorMode: string;
        operationFailed: boolean;
        operationResult: string;
        isExecuting: boolean;
        constructor(workspace: Workspace, operationsService: OperationsService);
        $onInit(): void;
        isResultHtml(): boolean;
        private static buildHelpText;
        private static convertToHtmlInputType;
        private static getDefaultValue;
        execute(): void;
    }
    const operationFormComponent: angular.IComponentOptions;
}
declare namespace Jmx {
    const operationsModule: string;
}
declare namespace Jmx {
    class TreeHeaderController {
        private $scope;
        private $element;
        filter: string;
        result: any[];
        constructor($scope: any, $element: JQuery);
        $onInit(): void;
        private search;
        private tree;
        expandAll(): any;
        contractAll(): any;
    }
}
declare namespace Jmx {
    const treeHeaderComponent: angular.IComponentOptions;
}
declare namespace Jmx {
    class TreeController {
        private $scope;
        private $location;
        private workspace;
        private $element;
        private $timeout;
        constructor($scope: ng.IScope, $location: ng.ILocationService, workspace: Workspace, $element: JQuery, $timeout: ng.ITimeoutService);
        $onInit(): void;
        updateSelectionFromURL(): void;
        private populateTree;
        private removeTree;
    }
    const treeComponent: angular.IComponentOptions;
}
declare namespace Jmx {
    const treeModule: string;
    const treeElementId = "#jmxtree";
}
declare namespace Jmx {
    function createWorkspace($location: ng.ILocationService, jmxTreeLazyLoadRegistry: any, $compile: ng.ICompileService, $templateCache: ng.ITemplateCacheService, localStorage: Storage, jolokia: Jolokia.IJolokia, jolokiaStatus: JVM.JolokiaStatus, $rootScope: any, userDetails: any): Workspace;
}
declare namespace Jmx {
    var jmxModule: angular.IModule;
    const log: Logging.Logger;
}
declare namespace Core {
    function setupPolling($scope: any, updateFunction: (next: () => void) => void, period?: number, $timeout?: ng.ITimeoutService, jolokia?: Jolokia.IJolokia): () => void;
}
declare namespace Jmx {
}
declare namespace Jmx {
}
declare namespace Jmx {
    /**
     * a NodeSelection interface so we can expose things like the objectName and the MBean's entries
     *
     * @class NodeSelection
     */
    interface NodeSelection {
        /**
         * @property text
         * @type string
         */
        text: string;
        /**
         * @property class
         * @type string
         */
        class?: string;
        /**
         * @property key
         * @type string
         * @optional
         */
        key?: string;
        /**
         * @property typeName
         * @type string
         * @optional
         */
        typeName?: string;
        /**
         * @property objectName
         * @type string
         * @optional
         */
        objectName?: string;
        /**
         * @property domain
         * @type string
         * @optional
         */
        domain?: string;
        /**
         * @property entries
         * @type any
         * @optional
         */
        entries?: any;
        /**
         * @property folderNames
         * @type array
         * @optional
         */
        folderNames?: string[];
        /**
         * @property children
         * @type NodeSelection
         * @optional
         */
        children?: Array<NodeSelection>;
        /**
         * @property parent
         * @type NodeSelection
         * @optional
         */
        parent?: NodeSelection;
        /**
         * @property icon
         * @type string
         * @optional
         */
        icon?: string;
        /**
         * @property image
         * @type string
         * @optional
         */
        image?: string;
        /**
         * @property version
         * @type string
         * @optional
         */
        version?: string;
        /**
         * @method get
         * @param {String} key
         * @return {NodeSelection}
         */
        get(key: string): NodeSelection;
        /**
         * @method isFolder
         * @return {boolean}
         */
        isFolder(): boolean;
        /**
         * @method ancestorHasType
         * @param {String} typeName
         * @return {Boolean}
         */
        ancestorHasType(typeName: string): boolean;
        /**
         * @method ancestorHasEntry
         * @param key
         * @param value
         * @return {Boolean}
         */
        ancestorHasEntry(key: string, value: any): boolean;
        /**
         * @method findDescendant
         * @param {Function} filter
         * @return {NodeSelection}
         */
        findDescendant(filter: (node: NodeSelection) => boolean): NodeSelection | null;
        /**
         * @method findAncestor
         * @param {Function} filter
         * @return {NodeSelection}
         */
        findAncestor(filter: (node: NodeSelection) => boolean): NodeSelection | null;
        /**
         * @method detach
         */
        detach(): any;
    }
    /**
     * @class Folder
     * @uses NodeSelection
     */
    class Folder implements NodeSelection {
        text: string;
        private readonly rootId;
        private readonly separator;
        constructor(text: string, root?: boolean);
        id: string;
        key: string;
        title: string;
        typeName: string;
        nodes: NodeSelection[];
        children: Array<NodeSelection>;
        folderNames: string[];
        domain: string;
        objectName: string;
        entries: {};
        class: string;
        parent: Folder;
        isLazy: boolean;
        lazyLoad: boolean;
        icon: string;
        image: string;
        tooltip: string;
        entity: any;
        version: string;
        mbean: MBean;
        init(domain: string, folderNames: string[]): void;
        configureClass(domainClass: string, folderNames: string[], path: string): void;
        configureMBean(entries: {}, objectName: string, mbean: Core.JMXMBean, typeName: string): void;
        get(key: string): NodeSelection;
        isFolder(): boolean;
        /**
         * Navigates the given paths and returns the value there or null if no value could be found
         * @method navigate
         * @for Folder
         * @param {Array} paths
         * @return {NodeSelection}
         */
        navigate(...paths: string[]): NodeSelection;
        hasEntry(key: string, value: any): boolean;
        parentHasEntry(key: string, value: any): boolean;
        ancestorHasEntry(key: string, value: any): boolean;
        ancestorHasType(typeName: string): boolean;
        getOrElse(key: string, defaultValue?: Folder): Folder;
        sortChildren(recursive: boolean): void;
        moveChild(child: NodeSelection): void;
        insertBefore(child: Folder, referenceFolder: Folder): void;
        insertAfter(child: Folder, referenceFolder: Folder): void;
        /**
         * Removes this node from my parent if I have one
         * @method detach
         * @for Folder
         */
        detach(): void;
        /**
         * Searches this folder and all its descendants for the first folder to match the filter
         * @method findDescendant
         * @for Folder
         * @param {Function} filter
         * @return {Folder}
         */
        findDescendant(filter: (node: NodeSelection) => boolean): NodeSelection | null;
        /**
         * Searches this folder and all its ancestors for the first folder to match the filter
         * @method findDescendant
         * @for Folder
         * @param {Function} filter
         * @return {Folder}
         */
        findAncestor(filter: (node: NodeSelection) => boolean): NodeSelection | null;
    }
    interface MBean extends Core.JMXMBean {
        opByString?: {
            [name: string]: any;
        };
    }
}
declare namespace Jmx {
    function findLazyLoadingFunction(workspace: Workspace, folder: any): (workspace: Workspace, folder: Folder, onComplete: (children: NodeSelection[]) => void) => void;
    function registerLazyLoadHandler(domain: string, lazyLoaderFactory: (folder: Folder) => any): void;
    function unregisterLazyLoadHandler(domain: string, lazyLoaderFactory: (folder: Folder) => any): void;
    function updateTreeSelectionFromURL($location: any, treeElement: any, activateIfNoneSelected?: boolean): void;
    function updateTreeSelectionFromURLAndAutoSelect($location: ng.ILocationService, treeElement: any, autoSelect: (Folder: any) => NodeSelection, activateIfNoneSelected?: boolean): void;
    function getUniqueTypeNames(children: NodeSelection[]): string[];
    function enableTree($scope: ng.IScope, $location: ng.ILocationService, workspace: Workspace, treeElement: any, children: Array<NodeSelection>): void;
}
declare namespace JVM {
}
declare namespace JVM {
    var HeaderController: angular.IModule;
}
/**
 * @module JVM
 */
declare namespace JVM {
}
declare namespace JVM {
}
declare namespace JVM {
    interface ConnectionTestResult {
        ok: boolean;
        message: string;
    }
}
declare namespace Karaf {
    class Feature {
        id: string;
        name: string;
        version: string;
        installed: boolean;
        required: boolean;
        repositoryName: string;
        repositoryUri: string;
        constructor(name: string, version: string, installed: boolean, required: boolean, repositoryName: string, repositoryUri: string);
        getState(): string;
    }
}
declare namespace Karaf {
    class FeatureRepository {
        name: string;
        uri: string;
        features: Feature[];
        dependencies: string[];
        constructor(name: string, uri: string);
    }
}
declare namespace Karaf {
    class FeaturesService {
        private jolokiaService;
        private workspace;
        constructor(jolokiaService: JVM.JolokiaService, workspace: Jmx.Workspace);
        getFeatureRepositories(mbean: string): ng.IPromise<FeatureRepository[]>;
        installFeature(mbean: string, feature: Feature): ng.IPromise<string>;
        uninstallFeature(mbean: string, feature: Feature): ng.IPromise<string>;
        addFeatureRepository(mbean: string, repositoryUri: string): ng.IPromise<string>;
        removeFeatureRepository(mbean: string, repository: FeatureRepository): ng.IPromise<string>;
        hasInvokeRightsForName(mbean: string, name: string): boolean;
        sortByName(a: any, b: any): number;
    }
}
declare namespace Karaf {
    class FeaturesController {
        private featuresService;
        private $uibModal;
        private workspace;
        private $timeout;
        private $q;
        private static FILTER_FUNCTIONS;
        private features;
        private repositories;
        private repositoryFilterValues;
        private mbean;
        listConfig: {
            showSelectBox: boolean;
            useExpandingRows: boolean;
            updateInProgress: boolean;
        };
        loading: boolean;
        listItems: any;
        private readonly installButton;
        private readonly uninstallButton;
        listItemActionButtons: any[];
        private readonly addRepositoryAction;
        private readonly removeRepositoryAction;
        toolbarConfig: {
            filterConfig: {
                fields: ({
                    id: string;
                    title: string;
                    placeholder: string;
                    filterType: string;
                    filterValues?: undefined;
                } | {
                    id: string;
                    title: string;
                    placeholder: string;
                    filterType: string;
                    filterValues: string[];
                })[];
                onFilterChange: (filters: any[]) => void;
                appliedFilters: any[];
                resultsCount: number;
            };
            actionsConfig: {
                primaryActions: any[];
            };
            isTableView: boolean;
        };
        pageConfig: {
            pageSize: number;
        };
        constructor(featuresService: FeaturesService, $uibModal: angular.ui.bootstrap.IModalService, workspace: Jmx.Workspace, $timeout: ng.ITimeoutService, $q: ng.IQService);
        $onInit(): void;
        private itemActionButtons;
        private toolbarActionButtons;
        private loadFeatureRepositories;
        private applyFilters;
        enableButtonForItem(action: any, item: any): boolean;
        private setUpdateInProgress;
        private runWithDelay;
    }
    const featuresComponent: angular.IComponentOptions;
}
declare namespace Karaf {
    class FeatureRepositoryAddModalController {
        private featuresService;
        private modalInstance;
        constructor(featuresService: FeaturesService);
        addRepository(uri: string): void;
    }
    const featureRepositoryAddModalComponent: angular.IComponentOptions;
}
declare namespace Karaf {
    class FeatureRepositoryRemoveModalController {
        private modalInstance;
        private resolve;
        private repositories;
        constructor();
        $onInit(): void;
        removeRepository(repository: FeatureRepository): void;
    }
    const featureRepositoryRemoveModalComponent: angular.IComponentOptions;
}
declare namespace Karaf {
    const featuresModule: string;
}
declare namespace Karaf {
    interface ScrComponent {
        id: number;
        bundleId: number;
        name: string;
        state: string;
        properties: any;
        references: any;
    }
}
declare namespace Karaf {
    class ScrComponentsService {
        private $q;
        private jolokia;
        private workspace;
        constructor($q: ng.IQService, jolokia: Jolokia.IJolokia, workspace: Jmx.Workspace);
        getComponents(): ng.IPromise<ScrComponent[]>;
        enableComponents(components: ScrComponent[]): ng.IPromise<string>;
        enableComponent(component: ScrComponent): ng.IPromise<string>;
        disableComponents(components: ScrComponent[]): ng.IPromise<string>;
        disableComponent(component: ScrComponent): ng.IPromise<string>;
        private execute;
        private handleResponse;
    }
}
declare namespace Karaf {
    class ScrComponentsController {
        private scrComponentsService;
        private workspace;
        private static FILTER_FUNCTIONS;
        private readonly enableAction;
        private readonly disableAction;
        private toolbarActions;
        private toolbarConfig;
        private tableConfig;
        private tableColumns;
        private tableItems;
        private components;
        private loading;
        constructor(scrComponentsService: ScrComponentsService, workspace: Jmx.Workspace);
        $onInit(): void;
        private loadComponents;
        private applyFilters;
        private enableDisableActions;
        private getSelectedComponents;
    }
    const scrListComponent: angular.IComponentOptions;
}
declare namespace Karaf {
    class ScrComponentDetailController {
        private scrComponentsService;
        private $routeParams;
        private workspace;
        component: ScrComponent;
        srcComponentsUrl: string;
        loading: boolean;
        scrMBean: string;
        constructor(scrComponentsService: ScrComponentsService, $routeParams: angular.route.IRouteParamsService, workspace: Jmx.Workspace);
        $onInit(): void;
        private loadComponent;
        disableComponentEnable(): boolean;
        enableComponent(): void;
        disableComponentDisable(): boolean;
        disableComponent(): void;
    }
    const scrDetailComponent: angular.IComponentOptions;
}
declare namespace Karaf {
    const scrComponentsModule: string;
}
declare namespace Karaf {
    const _module: angular.IModule;
}
declare namespace Karaf {
}
declare namespace Karaf {
}
declare namespace Karaf {
}
declare namespace Logs {
    class LogEntry {
        className: string;
        containerName: string;
        exception: string;
        fileName: string;
        hasOSGiProps: boolean;
        hasMDCProps: boolean;
        hasLogSourceHref: boolean;
        hasLogSourceLineHref: boolean;
        host: string;
        level: string;
        levelClass: string;
        lineNumber: string;
        logger: string;
        logSourceUrl: string;
        methodName: string;
        properties: {};
        mdcProperties: {};
        sanitizedMessage: string;
        seq: string;
        thread: string;
        timestamp: string;
        constructor(event: any);
        private static getLevelClass;
        private static hasOSGiProps;
        private static hasLogSourceHref;
        private static hasLogSourceLineHref;
        private static getLogSourceUrl;
        private static removeQuestion;
        static mdcProperties(properties: {}): {};
        matchMessage(keyword: string): boolean;
        matchProperties(keyword: string): boolean;
    }
}
declare namespace Logs {
    class LogsService {
        private $q;
        private jolokiaService;
        private localStorage;
        private workspace;
        constructor($q: ng.IQService, jolokiaService: JVM.JolokiaService, localStorage: Storage, workspace: Jmx.Workspace);
        getLogQueryMBean(): Jmx.Folder;
        isValid(): boolean;
        getInitialLogs(): ng.IPromise<any>;
        getMoreLogs(fromTimestamp: number): ng.IPromise<LogEntry[]>;
        private getLogs;
        appendLogs(logs: LogEntry[], logEntries: LogEntry[]): LogEntry[];
        filterLogs(logs: LogEntry[], filterConfig: any): LogEntry[];
        isLogSortAsc(): boolean;
        isLogAutoScroll(): boolean;
        getLogCacheSize(): number;
        getLogBatchSize(): number;
    }
}
declare namespace Logs {
    function configureLogsPreferences(preferencesRegistry: any, logsService: LogsService): void;
}
declare namespace Logs {
    function LogsPreferencesController($scope: any, localStorage: any): void;
}
declare namespace Logs {
    const logsPreferencesModule: string;
}
declare namespace Logs {
    class LogModalController {
        resolve: {
            logEntry: LogEntry;
        };
        readonly logEntry: LogEntry;
    }
    const logModalComponent: angular.IComponentOptions;
}
declare namespace Logs {
    class LogsController {
        private $timeout;
        private $uibModal;
        private logsService;
        logs: any[];
        filteredLogs: any[];
        messageSearchText: any[];
        loading: boolean;
        toolbarConfig: {
            filterConfig: {
                fields: ({
                    id: string;
                    title: string;
                    placeholder: string;
                    filterType: string;
                    filterValues: string[];
                } | {
                    id: string;
                    title: string;
                    placeholder: string;
                    filterType: string;
                    filterValues?: undefined;
                })[];
                totalCount: number;
                resultsCount: number;
                appliedFilters: any[];
                onFilterChange: (filters: any[]) => void;
            };
            isTableView: boolean;
        };
        scrollableTable: any;
        constructor($timeout: any, $uibModal: any, logsService: LogsService);
        $onInit(): void;
        applyFilters(filters: any[]): void;
        removePreviousLevelFilter(filters: any[]): void;
        getMessageFilterValues(filters: any[]): any[];
        openLogModal(logEntry: LogEntry): void;
        processLogEntries(response: any): void;
        scheduleNextRequest(fromTimestamp: number): void;
        isTableScrolled(): boolean;
        scrollTable(): void;
    }
    const logsComponent: angular.IComponentOptions;
}
declare namespace Logs {
    function configureLogsRoutes($routeProvider: ng.route.IRouteProvider): void;
    function configureLogsHelp(helpRegistry: Help.HelpRegistry, logsService: LogsService): void;
    function configureLogsMainNav(mainNavService: Nav.MainNavService, logsService: LogsService): void;
}
declare namespace Logs {
    function logDateFilter($filter: any): (log: any) => any;
    /**
     * @param text {string} haystack to search through
     * @param search {string} needle to search for
     * @param [caseSensitive] {boolean} optional boolean to use case-sensitive searching
     */
    function highlight(): (text: string, searches: string[], caseSensitive: boolean) => string;
}
declare namespace Logs {
    const logsModule: string;
}
declare namespace Logs {
}
declare namespace Osgi {
    function formatServiceName(objClass: any): string;
}
declare namespace Osgi {
}
declare namespace Osgi {
    var configuration: {
        pidMetadata: {
            "io.fabric8.container.java": {
                name: string;
            };
            "io.fabric8.container.process": {
                name: string;
            };
            "io.fabric8.container.process.overlay.resources": {
                name: string;
                description: string;
                schemaExtensions: {
                    disableHumanizeLabel: boolean;
                };
            };
            "io.fabric8.dosgi": {
                name: string;
                description: string;
            };
            "io.fabric8.environment": {
                name: string;
                description: string;
                schemaExtensions: {
                    disableHumanizeLabel: boolean;
                };
            };
            "io.fabric8.fab.osgi.url": {
                name: string;
                description: string;
            };
            "io.fabric8.mq.fabric.server": {
                name: string;
                description: string;
            };
            "io.fabric8.openshift": {
                name: string;
            };
            "io.fabric8.ports": {
                name: string;
                description: string;
                schemaExtensions: {
                    disableHumanizeLabel: boolean;
                };
            };
            "io.fabric8.system": {
                name: string;
                description: string;
                schemaExtensions: {
                    disableHumanizeLabel: boolean;
                };
            };
            "io.fabric8.version": {
                name: string;
                schemaExtensions: {
                    disableHumanizeLabel: boolean;
                };
            };
            "org.ops4j.pax.logging": {
                name: string;
                description: string;
            };
            "org.ops4j.pax.url.mvn": {
                name: string;
                description: string;
            };
            "org.ops4j.pax.url.war": {
                name: string;
                description: string;
            };
            "org.ops4j.pax.url.wrap": {
                name: string;
                description: string;
            };
        };
        ignorePids: string[];
        tabs: {
            "fabric8": {
                label: string;
                description: string;
                pids: string[];
            };
            "karaf": {
                label: string;
                description: string;
                pids: string[];
            };
        };
    };
}
declare namespace Osgi {
    var TopLevelController: angular.IModule;
}
declare namespace Osgi {
    var PackagesController: angular.IModule;
}
declare namespace Osgi {
    var ServiceController: angular.IModule;
}
declare namespace RBAC {
    class JmxTreeProcessor {
        private jolokia;
        private jolokiaStatus;
        private rbacTasks;
        constructor(jolokia: Jolokia.IJolokia, jolokiaStatus: JVM.JolokiaStatus, rbacTasks: RBACTasks);
        /**
         * Process JMX tree and attach RBAC info (canInvoke) to it in advance.
         *
         * Matrix of supported RBAC Mbeans per platform:
         * +-------------------------+-----------+--------------+---------------+-------------------+
         * |        Platform         | ACL MBean | RBACRegistry | RBACDecorator |  Process method   |
         * +-------------------------+-----------+--------------+---------------+-------------------+
         * | Karaf                   | o         | o            | o             | processWithRBAC() |
         * | WildFly                 | x (dummy) | o            | x             | processGeneral()  |
         * | Spring Boot             | x (dummy) | o            | x             | processGeneral()  |
         * | Artemis                 | o         | o            | x             | processGeneral()  |
         * | Jolokia (no hawtio.war) | x         | x            | x             | processGeneral()  |
         * +-------------------------+-----------+--------------+---------------+-------------------+
         *
         * Object names for the RBAC MBeans:
         * - ACL MBean:     "*:type=security,area=jmx,*"
         * - RBACRegistry:  "hawtio:type=security,name=RBACRegistry"
         * - RBACDecorator: "hawtio:type=security,area=jolokia,name=RBACDecorator"
         */
        process(tree: Jmx.Folder): void;
        private flatten;
        /**
         * Recursive method to flatten MBeans folder
         */
        private flattenFolder;
        /**
         * Check if RBACDecorator has been applied to the MBean tree at server side.
         */
        private hasDecoratedRBAC;
        private processWithRBAC;
        private processGeneral;
        private addCanInvokeRequests;
        private addOperation;
        private applyCanInvoke;
        private addCanInvokeToClass;
        private stripClasses;
        private addClass;
    }
}
declare namespace RBAC {
    /**
     * Directive that sets an element's visibility to hidden if the user cannot invoke the supplied operation
     */
    class HawtioShow implements ng.IDirective {
        private workspace;
        restrict: string;
        constructor(workspace: Jmx.Workspace);
        static factory(workspace: Jmx.Workspace): HawtioShow;
        link(scope: ng.IScope, element: ng.IAugmentedJQuery, attr: ng.IAttributes): void;
        private applyInvokeRights;
        private getCanInvokeOperation;
        private getArguments;
        private changeDisplay;
    }
}
declare namespace RBAC {
    class RBACTasksFactory {
        static create(postLoginTasks: Core.Tasks, jolokia: Jolokia.IJolokia, $q: ng.IQService): RBACTasks;
    }
    class RBACACLMBeanFactory {
        static create(rbacTasks: RBACTasks): ng.IPromise<string>;
    }
}
/**
 * @namespace RBAC
 * @main RBAC
 */
declare namespace RBAC {
    const pluginName: string;
    const log: Logging.Logger;
}
declare namespace Runtime {
    class RuntimeService {
        private workspace;
        constructor(workspace: Jmx.Workspace);
        getTabs(): Nav.HawtioTab[];
    }
}
declare namespace Runtime {
    class RuntimeController {
        private runtimeService;
        tabs: Nav.HawtioTab[];
        constructor(runtimeService: RuntimeService);
        $onInit(): void;
    }
    const runtimeComponent: angular.IComponentOptions;
}
declare namespace Runtime {
    function configureRoutes($routeProvider: angular.route.IRouteProvider): void;
    function configureHelp(helpRegistry: Help.HelpRegistry): void;
    function configureMainNav(mainNavService: Nav.MainNavService, workspace: Jmx.Workspace): void;
}
declare namespace Runtime {
    interface SystemProperty {
        name: string;
        value: string;
    }
}
declare namespace Runtime {
    class SystemPropertiesService {
        private jolokiaService;
        constructor(jolokiaService: JVM.JolokiaService);
        getSystemProperties(): ng.IPromise<SystemProperty[]>;
    }
}
declare namespace Runtime {
    class SystemPropertiesController {
        private systemPropertiesService;
        private toolbarConfig;
        private tableConfig;
        private pageConfig;
        private tableColumns;
        private tableDtOptions;
        private sysprops;
        private tableItems;
        constructor(systemPropertiesService: SystemPropertiesService);
        $onInit(): void;
        private loadData;
        private applyFilters;
    }
    const systemPropertiesComponent: angular.IComponentOptions;
}
declare namespace Runtime {
    const systemPropertiesModule: string;
}
declare namespace Runtime {
    class MetricsService {
        private jolokia;
        private workspace;
        constructor(jolokia: Jolokia.IJolokia, workspace: Jmx.Workspace);
        registerJolokiaRequests(scope: ng.IScope, callback: any): void;
        unregisterJolokiaRequests(scope: ng.IScope): void;
        createMetric(name: string, value: any, unit?: string): Metric;
        createUtilizationMetric(name: string, used: any, total: any, unit?: string): UtilizationMetric;
        private createMBeanRequest;
    }
}
declare namespace Runtime {
    enum MetricType {
        JVM = "JVM",
        SYSTEM = "System",
        SPRING_BOOT = "Spring Boot"
    }
    class Metric {
        name: string;
        value: any;
        unit?: string;
        constructor(name: string, value: any, unit?: string);
        getDescription(): string;
    }
    class UtilizationMetric extends Metric {
        name: string;
        value: any;
        available: any;
        unit: string;
        constructor(name: string, value: any, available: any, unit: string);
        getDescription(): string;
    }
    class MetricGroup {
        type: MetricType;
        metrics: Metric[];
        constructor(type: MetricType, metrics?: Metric[]);
        updateMetrics(metrics: Metric[]): void;
    }
}
declare namespace Runtime {
    class MetricsController {
        private $scope;
        private metricsService;
        private $filter;
        private humanizeService;
        private loading;
        private metricGroups;
        constructor($scope: any, metricsService: MetricsService, $filter: ng.IFilterService, humanizeService: Core.HumanizeService);
        $onInit(): void;
        $onDestroy(): void;
        private loadMetrics;
        private getMetricGroup;
        private formatBytes;
    }
    const metricsComponent: angular.IComponentOptions;
}
declare namespace Runtime {
    const metricsModule: string;
}
declare namespace Runtime {
    class Thread {
        blockedCount: number;
        blockedTime: string;
        inNative: boolean;
        lockInfo: object;
        lockOwnerId: number;
        lockOwnerName: string;
        lockedMonitors: any[];
        lockedSynchronizers: any[];
        suspended: boolean;
        threadId: number;
        threadName: string;
        threadState: string;
        waitedCount: number;
        waitedTime: string;
    }
}
declare namespace Runtime {
    class ThreadsService {
        private jolokiaService;
        private static STATE_LABELS;
        constructor(jolokiaService: JVM.JolokiaService);
        getThreads(): angular.IPromise<Thread[]>;
        isThreadContentionMonitoringEnabled(): angular.IPromise<boolean>;
        enableThreadContentionMonitoring(): angular.IPromise<void>;
        disableThreadContentionMonitoring(): angular.IPromise<void>;
    }
}
declare namespace Runtime {
    class ThreadsController {
        private $interval;
        private $uibModal;
        private threadsService;
        FILTER_FUNCTIONS: {
            state: (threads: any, state: any) => any;
            name: (threads: any, name: any) => any;
        };
        allThreads: Thread[];
        filteredThreads: Thread[];
        threadContentionMonitoringEnabled: boolean;
        intervalId: any;
        toolbarActions: any[];
        enableThreadContentionMonitoringAction: {
            name: string;
            actionFn: () => void;
        };
        disableThreadContentionMonitoringAction: {
            name: string;
            actionFn: () => void;
        };
        toolbarConfig: {
            filterConfig: {
                fields: ({
                    id: string;
                    title: string;
                    placeholder: string;
                    filterType: string;
                    filterValues: string[];
                } | {
                    id: string;
                    title: string;
                    placeholder: string;
                    filterType: string;
                    filterValues?: undefined;
                })[];
                onFilterChange: (filters: any[]) => void;
                resultsCount: number;
                appliedFilters: any[];
            };
            actionsConfig: {
                primaryActions: any[];
            };
            isTableView: boolean;
        };
        tableConfig: {
            selectionMatchProp: string;
            showCheckboxes: boolean;
        };
        tableDtOptions: {
            order: (string | number)[][];
        };
        tableColumns: ({
            header: string;
            itemField: string;
            templateFn?: undefined;
        } | {
            header: string;
            itemField: string;
            templateFn: (value: any) => string;
        })[];
        tableActionButtons: {
            name: string;
            title: string;
            actionFn: (action: any, thread: any) => void;
        }[];
        constructor($interval: ng.IIntervalService, $uibModal: angular.ui.bootstrap.IModalService, threadsService: ThreadsService);
        $onInit(): void;
        $onDestroy(): void;
        showThreadContentionMonitoringView(): void;
        loadThreads(): void;
        applyFilters(filters: any[]): void;
        enableThreadContentionMonitoring(): void;
        showThreadContentionMonitoringEnabledView(): void;
        disableThreadContentionMonitoring(): void;
        showThreadContentionMonitoringDisabledView(): void;
    }
    const threadsComponent: angular.IComponentOptions;
}
declare namespace Runtime {
    class ThreadModalController {
        resolve: {
            thread: Thread;
        };
        readonly thread: Thread;
    }
    const threadModalComponent: angular.IComponentOptions;
}
declare namespace Runtime {
    const threadsModule: string;
}
declare namespace Runtime {
    const log: Logging.Logger;
}