@angular-wave/angular.ts 0.9.1 → 0.9.3

package/@types/router/url/url-service.d.ts

@@ -0,0 +1,254 @@
+/**
+ * API for URL management
+ */
+export class UrlService {
+  static $inject: string[];
+  /**
+   * @param {import("../../services/location/location").LocationProvider} $locationProvider
+   * @param {import("../../router/state/state-service.js").StateProvider} stateService
+   * @param {import("../router.js").Router} globals
+   * @param {import("../../router/url/url-config.js").UrlConfigProvider} urlConfigProvider
+   */
+  constructor(
+    $locationProvider: any,
+    stateService: import("../../router/state/state-service.js").StateProvider,
+    globals: import("../router.js").Router,
+    urlConfigProvider: import("../../router/url/url-config.js").UrlConfigProvider,
+  );
+  /** @type {import("../../services/location/location").Location} */
+  $location: any;
+  $locationProvider: any;
+  stateService: import("../../router/state/state-service.js").StateProvider;
+  /** Provides services related to the URL */
+  urlRuleFactory: UrlRuleFactory;
+  /**
+   * The nested [[UrlRules]] API for managing URL rules and rewrites
+   * @type {UrlRules}
+   */
+  rules: UrlRules;
+  /**
+   * The nested [[UrlConfig]] API to configure the URL and retrieve URL information
+   * @type {import("./url-config.js").UrlConfigProvider}
+   */
+  config: import("./url-config.js").UrlConfigProvider;
+  /** Creates a new [[Param]] for a given location (DefType) */
+  paramFactory: ParamFactory;
+  _urlListeners: any[];
+  /**
+   * Gets the path part of the current url
+   *
+   * If the current URL is `/some/path?query=value#anchor`, this returns `/some/path`
+   *
+   * @return {string} the path portion of the url
+   */
+  getPath(): string;
+  /**
+   * Gets the search part of the current url as an object
+   *
+   * If the current URL is `/some/path?query=value#anchor`, this returns `{ query: 'value' }`
+   *
+   * @return {Object} the search (query) portion of the url, as an object
+   */
+  getSearch(): any;
+  /**
+   * Gets the hash part of the current url
+   *
+   * If the current URL is `/some/path?query=value#anchor`, this returns `anchor`
+   *
+   * @return {string} the hash (anchor) portion of the url
+   */
+  getHash(): string;
+  $get: (
+    | string
+    | ((
+        $location: import("../../services/location/location.js").Location,
+        $rootScope: import("../../core/scope/scope.js").Scope,
+      ) => UrlService)
+  )[];
+  /**
+   * @returns {string}
+   */
+  baseHref(): string;
+  _baseHref: string;
+  /**
+   * Gets the current url, or updates the url
+   *
+   * ### Getting the current URL
+   *
+   * When no arguments are passed, returns the current URL.
+   * The URL is normalized using the internal [[path]]/[[search]]/[[hash]] values.
+   *
+   * For example, the URL may be stored in the hash ([[HashLocationServices]]) or
+   * have a base HREF prepended ([[PushStateLocationServices]]).
+   *
+   * The raw URL in the browser might be:
+   *
+   * ```
+   * http://mysite.com/somepath/index.html#/internal/path/123?param1=foo#anchor
+   * ```
+   *
+   * or
+   *
+   * ```
+   * http://mysite.com/basepath/internal/path/123?param1=foo#anchor
+   * ```
+   *
+   * then this method returns:
+   *
+   * ```
+   * /internal/path/123?param1=foo#anchor
+   * ```
+   *
+   *
+   * #### Example:
+   * ```js
+   * locationServices.url(); // "/some/path?query=value#anchor"
+   * ```
+   *
+   * ### Updating the URL
+   *
+   * When `newurl` arguments is provided, changes the URL to reflect `newurl`
+   *
+   * #### Example:
+   * ```js
+   * locationServices.url("/some/path?query=value#anchor", true);
+   * ```
+   *
+   * @param {string} [newUrl] The new value for the URL.
+   *               This url should reflect only the new internal [[path]], [[search]], and [[hash]] values.
+   *               It should not include the protocol, site, port, or base path of an absolute HREF.
+   * @param {any} [state] The history's state object, i.e., pushState (if the LocationServices implementation supports it)
+   *
+   * @return the url (after potentially being processed)
+   */
+  url(newUrl?: string, state?: any): any;
+  /**
+   * @private
+   *
+   * Registers a low level url change handler
+   *
+   * Note: Because this is a low level handler, it's not recommended for general use.
+   *
+   * #### Example:
+   * ```js
+   * let deregisterFn = locationServices.onChange((evt) => console.log("url change", evt));
+   * ```
+   *
+   * @param {Function} callback a function that will be called when the url is changing
+   * @return {Function} a function that de-registers the callback
+   */
+  private onChange;
+  /**
+   * Gets the current URL parts.
+   *
+   * Returns an object with the `path`, `search`, and `hash` components
+   * of the current browser location.
+   *
+   * @returns {import("../../services/location/interface.ts").UrlParts} The current URL's path, search, and hash.
+   */
+  parts(): import("../../services/location/interface.ts").UrlParts;
+  /**
+   * Activates the best rule for the current URL
+   *
+   * Checks the current URL for a matching [[UrlRule]], then invokes that rule's handler.
+   * This method is called internally any time the URL has changed.
+   *
+   * This effectively activates the state (or redirect, etc) which matches the current URL.
+   *
+   * #### Example:
+   * ```js
+   *
+   * fetch('/states.json').then(resp => resp.json()).then(data => {
+   *   data.forEach(state => $stateRegistry.register(state));
+   *   urlService.listen();
+   *   // Find the matching URL and invoke the handler.
+   *   urlService.sync();
+   * });
+   * ```
+   */
+  sync(evt: any): void;
+  /**
+   * Starts or stops listening for URL changes
+   *
+   * Call this sometime after calling [[deferIntercept]] to start monitoring the url.
+   * This causes ng-router to start listening for changes to the URL, if it wasn't already listening.
+   *
+   * If called with `false`, ng-router will stop listening (call listen(true) to start listening again).
+   *
+   * #### Example:
+   * ```js
+   *
+   * fetch('/states.json').then(resp => resp.json()).then(data => {
+   *   data.forEach(state => $stateRegistry.register(state));
+   *   // Start responding to URL changes
+   *   urlService.listen();
+   *   urlService.sync();
+   * });
+   * ```
+   *
+   * @param {boolean} enabled `true` or `false` to start or stop listening to URL changes
+   */
+  listen(enabled: boolean): any;
+  _stopListeningFn: any;
+  /**
+   * Matches a URL
+   *
+   * Given a URL (as a [[UrlParts]] object), check all rules and determine the best matching rule.
+   * Return the result as a [[MatchResult]].
+   * @returns {any}
+   */
+  match(url: any): any;
+  update(read: any): void;
+  location: any;
+  /**
+   * Internal API.
+   *
+   * Pushes a new location to the browser history.
+   *
+   * @internal
+   * @param urlMatcher
+   * @param params
+   * @param options
+   */
+  push(urlMatcher: any, params: any, options: any): void;
+  /**
+   * Builds and returns a URL with interpolated parameters
+   *
+   * #### Example:
+   * ```js
+   * matcher = $umf.compile("/about/:person");
+   * params = { person: "bob" };
+   * $bob = $url.href(matcher, params);
+   * // $bob == "/about/bob";
+   * ```
+   *
+   * @param urlMatcher The [[UrlMatcher]] object which is used as the template of the URL to generate.
+   * @param params An object of parameter values to fill the matcher's required parameters.
+   * @param options Options object. The options are:
+   *
+   * - **`absolute`** - {boolean=false},  If true will generate an absolute url, e.g. "http://www.example.com/fullurl".
+   *
+   * @returns Returns the fully compiled URL, or `null` if `params` fail validation against `urlMatcher`
+   */
+  href(urlMatcher: any, params: any, options: any): any;
+  /**
+   * Creates a [[UrlMatcher]] for the specified pattern.
+   *
+   * @param pattern  The URL pattern.
+   * @param config  The config object hash.
+   * @returns The UrlMatcher.
+   */
+  compile(pattern: any, config: any): UrlMatcher;
+  /**
+   * Returns true if the specified object is a [[UrlMatcher]], or false otherwise.
+   *
+   * @param object  The object to perform the type check against.
+   * @returns `true` if the object matches the `UrlMatcher` interface, by
+   *          implementing all the same methods.
+   */
+  isMatcher(object: any): boolean;
+}
+import { UrlRuleFactory } from "./url-rule.js";
+import { UrlRules } from "./url-rules.js";
+import { ParamFactory } from "../params/param-factory.js";
+import { UrlMatcher } from "./url-matcher.js";

package/@types/router/view/interface.d.ts

@@ -0,0 +1,44 @@
+import { ViewDeclaration } from "../state/interface.ts";
+import { PathNode } from "../path/path-node.js";
+/** The context ref can be anything that has a `name` and a `parent` reference to another IContextRef */
+export interface ViewContext {
+  name: string;
+  parent: ViewContext;
+}
+export interface ActiveUIView {
+  /** An auto-incremented id */
+  id: number;
+  /** The ui-view short name */
+  name: string;
+  /** The ui-view's fully qualified name */
+  fqn: string;
+  /** The ViewConfig that is currently loaded into the ui-view */
+  config: ViewConfig;
+  /** The state context in which the ui-view tag was created. */
+  creationContext: ViewContext;
+  /** A callback that should apply a ViewConfig (or clear the ui-view, if config is undefined) */
+  configUpdated: (config: ViewConfig) => void;
+}
+/**
+ * This interface represents a [[_ViewDeclaration]] that is bound to a [[PathNode]].
+ *
+ * A `ViewConfig` is the runtime definition of a single view.
+ *
+ * During a transition, `ViewConfig`s are created for each [[_ViewDeclaration]] defined on each "entering" [[StateObject]].
+ * Then, the [[ViewService]] finds any matching `ui-view`(s) in the DOM, and supplies the ui-view
+ * with the `ViewConfig`.  The `ui-view` then loads itself using the information found in the `ViewConfig`.
+ *
+ * A `ViewConfig` if matched with a `ui-view` by finding all `ui-view`s which were created in the
+ * context named by the `uiViewContextAnchor`, and finding the `ui-view` or child `ui-view` that matches
+ * the `uiViewName` address.
+ */
+export interface ViewConfig {
+  $id: number;
+  /** The normalized view declaration from [[State.views]] */
+  viewDecl: ViewDeclaration;
+  /** The node the ViewConfig is bound to */
+  path: PathNode[];
+  loaded: boolean;
+  /** Fetches templates, runs dynamic (controller|template)Provider code, lazy loads Components, etc */
+  load(): Promise<ViewConfig>;
+}

package/@types/router/view/view.d.ts

@@ -0,0 +1,149 @@
+/**
+ * The View service
+ *
+ * This service pairs existing `ng-view` components (which live in the DOM)
+ * with view configs (from the state declaration objects: [[StateDeclaration.views]]).
+ *
+ * - After a successful Transition, the views from the newly entered states are activated via [[activateViewConfig]].
+ *   The views from exited states are deactivated via [[deactivateViewConfig]].
+ *   (See: the [[registerActivateViews]] Transition Hook)
+ *
+ * - As `ng-view` components pop in and out of existence, they register themselves using [[registerUIView]].
+ *
+ * - When the [[sync]] function is called, the registered `ng-view`(s) ([[ActiveUIView]])
+ * are configured with the matching [[ViewConfig]](s)
+ *
+ */
+export class ViewService {
+  _ngViews: any[];
+  _viewConfigs: any[];
+  _viewConfigFactories: {};
+  _listeners: any[];
+  _pluginapi: {
+    _registeredUIView: (id: any) => undefined;
+    _registeredUIViews: () => any[];
+    _activeViewConfigs: () => any[];
+    _onSync: (listener: any) => () => any;
+  };
+  $get: (() => this)[];
+  /**
+   * @param {?import('../state/state-object.js').StateObject} context
+   * @return {?import('../state/state-object.js').StateObject}
+   */
+  rootViewContext(
+    context: import("../state/state-object.js").StateObject | null,
+  ): import("../state/state-object.js").StateObject | null;
+  _rootContext: any;
+  viewConfigFactory(factory: any): void;
+  /**
+   * @param path
+   * @param decl
+   * @return {import("../state/views.js").ViewConfig}
+   */
+  createViewConfig(
+    path: any,
+    decl: any,
+  ): import("../state/views.js").ViewConfig;
+  /**
+   * Deactivates a ViewConfig.
+   *
+   * This function deactivates a `ViewConfig`.
+   * After calling [[sync]], it will un-pair from any `ng-view` with which it is currently paired.
+   *
+   * @param viewConfig The ViewConfig view to deregister.
+   */
+  deactivateViewConfig(viewConfig: any): void;
+  activateViewConfig(viewConfig: any): void;
+  sync(): void;
+  /**
+   * Registers a `ng-view` component
+   *
+   * When a `ng-view` component is created, it uses this method to register itself.
+   * After registration the [[sync]] method is used to ensure all `ng-view` are configured with the proper [[ViewConfig]].
+   *
+   * Note: the `ng-view` component uses the `ViewConfig` to determine what view should be loaded inside the `ng-view`,
+   * and what the view's state context is.
+   *
+   * Note: There is no corresponding `deregisterUIView`.
+   *       A `ng-view` should hang on to the return value of `registerUIView` and invoke it to deregister itself.
+   *
+   * @param ngView The metadata for a UIView
+   * @return a de-registration function used when the view is destroyed.
+   */
+  registerUIView(ngView: any): () => void;
+  /**
+   * Returns the list of views currently available on the page, by fully-qualified name.
+   *
+   * @return {Array} Returns an array of fully-qualified view names.
+   */
+  available(): any[];
+  /**
+   * Returns the list of views on the page containing loaded content.
+   *
+   * @return {Array} Returns an array of fully-qualified view names.
+   */
+  active(): any[];
+}
+export namespace ViewService {
+  /**
+   * Given a ng-view and a ViewConfig, determines if they "match".
+   *
+   * A ng-view has a fully qualified name (fqn) and a context object.  The fqn is built from its overall location in
+   * the DOM, describing its nesting relationship to any parent ng-view tags it is nested inside of.
+   *
+   * A ViewConfig has a target ng-view name and a context anchor.  The ng-view name can be a simple name, or
+   * can be a segmented ng-view path, describing a portion of a ng-view fqn.
+   *
+   * In order for a ng-view to match ViewConfig, ng-view's $type must match the ViewConfig's $type
+   *
+   * If the ViewConfig's target ng-view name is a simple name (no dots), then a ng-view matches if:
+   * - the ng-view's name matches the ViewConfig's target name
+   * - the ng-view's context matches the ViewConfig's anchor
+   *
+   * If the ViewConfig's target ng-view name is a segmented name (with dots), then a ng-view matches if:
+   * - There exists a parent ng-view where:
+   *    - the parent ng-view's name matches the first segment (index 0) of the ViewConfig's target name
+   *    - the parent ng-view's context matches the ViewConfig's anchor
+   * - And the remaining segments (index 1..n) of the ViewConfig's target name match the tail of the ng-view's fqn
+   *
+   * Example:
+   *
+   * DOM:
+   * <ng-view>                        <!-- created in the root context (name: "") -->
+   *   <ng-view name="foo">                <!-- created in the context named: "A"      -->
+   *     <ng-view>                    <!-- created in the context named: "A.B"    -->
+   *       <ng-view name="bar">            <!-- created in the context named: "A.B.C"  -->
+   *       </ng-view>
+   *     </ng-view>
+   *   </ng-view>
+   * </ng-view>
+   *
+   * ngViews: [
+   *  { fqn: "$default",                  creationContext: { name: "" } },
+   *  { fqn: "$default.foo",              creationContext: { name: "A" } },
+   *  { fqn: "$default.foo.$default",     creationContext: { name: "A.B" } }
+   *  { fqn: "$default.foo.$default.bar", creationContext: { name: "A.B.C" } }
+   * ]
+   *
+   * These four view configs all match the ng-view with the fqn: "$default.foo.$default.bar":
+   *
+   * - ViewConfig1: { ngViewName: "bar",                       ngViewContextAnchor: "A.B.C" }
+   * - ViewConfig2: { ngViewName: "$default.bar",              ngViewContextAnchor: "A.B" }
+   * - ViewConfig3: { ngViewName: "foo.$default.bar",          ngViewContextAnchor: "A" }
+   * - ViewConfig4: { ngViewName: "$default.foo.$default.bar", ngViewContextAnchor: "" }
+   *
+   * Using ViewConfig3 as an example, it matches the ng-view with fqn "$default.foo.$default.bar" because:
+   * - The ViewConfig's segmented target name is: [ "foo", "$default", "bar" ]
+   * - There exists a parent ng-view (which has fqn: "$default.foo") where:
+   *    - the parent ng-view's name "foo" matches the first segment "foo" of the ViewConfig's target name
+   *    - the parent ng-view's context "A" matches the ViewConfig's anchor context "A"
+   * - And the remaining segments [ "$default", "bar" ].join("."_ of the ViewConfig's target name match
+   *   the tail of the ng-view's fqn "default.bar"
+   *
+   * @internal
+   */
+  function matches(
+    ngViewsByFqn: any,
+    ngView: any,
+  ): (viewConfig: any) => boolean;
+}

package/@types/router/view-scroll.d.ts

@@ -0,0 +1,10 @@
+export class ViewScrollProvider {
+  enabled: boolean;
+  useAnchorScroll(): void;
+  $get: (
+    | string
+    | ((
+        $anchorScroll: import("../services/anchor-scroll.js").AnchorScrollObject,
+      ) => import("../services/anchor-scroll.js").AnchorScrollObject | Function)
+  )[];
+}

package/@types/services/anchor-scroll.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @typedef {Object} AnchorScrollObject
+ * @property {number|function|Element} yOffset
+ */
+/**
+ * @typedef {(string) => void} AnchorScrollFunction
+ */
+/**
+ * @typedef {AnchorScrollFunction | AnchorScrollObject} AnchorScrollService
+ */
+export class AnchorScrollProvider {
+  autoScrollingEnabled: boolean;
+  $get: (
+    | string
+    | ((
+        $location: import("../services/location/location.js").Location,
+        $rootScope: import("../core/scope/scope.js").Scope,
+      ) => AnchorScrollFunction)
+  )[];
+}
+export type AnchorScrollObject = {
+  yOffset: number | Function | Element;
+};
+export type AnchorScrollFunction = (string: any) => void;
+export type AnchorScrollService = AnchorScrollFunction | AnchorScrollObject;

package/@types/services/cookie-reader.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @returns {Object<String, String>} List of all cookies
+ */
+export function getCookies(): any;

package/@types/services/http/http.d.ts

@@ -0,0 +1,134 @@
+/**
+ * Default params serializer that converts objects to strings
+ * according to the following rules:
+ *
+ * * `{'foo': 'bar'}` results in `foo=bar`
+ * * `{'foo': Date.now()}` results in `foo=2015-04-01T09%3A50%3A49.262Z` (`toISOString()` and encoded representation of a Date object)
+ * * `{'foo': ['bar', 'baz']}` results in `foo=bar&foo=baz` (repeated key for each array element)
+ * * `{'foo': {'bar':'baz'}}` results in `foo=%7B%22bar%22%3A%22baz%22%7D` (stringified and encoded representation of an object)
+ *
+ * Note that serializer will sort the request parameters alphabetically.
+ */
+export function HttpParamSerializerProvider(): void;
+export class HttpParamSerializerProvider {
+  $get: () => (params: any) => string;
+}
+export function defaultHttpResponseTransform(data: any, headers: any): any;
+/**
+ * Use `$httpProvider` to change the default behavior of the {@link ng.$http $http} service.
+ */
+export function HttpProvider(): void;
+export class HttpProvider {
+  defaults: {
+    transformResponse: (typeof defaultHttpResponseTransform)[];
+    transformRequest: ((d: any) => any)[];
+    headers: {
+      common: {
+        Accept: string;
+      };
+      post: any;
+      put: any;
+      patch: any;
+    };
+    xsrfCookieName: string;
+    xsrfHeaderName: string;
+    paramSerializer: string;
+  };
+  /**
+   * Configure $http service to combine processing of multiple http responses received at around
+   * the same time via {@link ng.$rootScope.Scope#$applyAsync $rootScope.$applyAsync}. This can result in
+   * significant performance improvement for bigger applications that make many HTTP requests
+   * concurrently (common during application bootstrap).
+   *
+   * Defaults to false. If no value is specified, returns the current configured value.
+   *
+   * @param {boolean=} value If true, when requests are loaded, they will schedule a deferred
+   *    "apply" on the next tick, giving time for subsequent requests in a roughly ~10ms window
+   *    to load and share the same digest cycle.
+   *
+   * @returns {boolean|Object} If a value is specified, returns the $httpProvider for chaining.
+   *    otherwise, returns the current configured value.
+   */
+  useApplyAsync: (value?: boolean | undefined) => boolean | any;
+  /**
+   * Array containing service factories for all synchronous or asynchronous {@link ng.$http $http}
+   * pre-processing of request or postprocessing of responses.
+   *
+   * These service factories are ordered by request, i.e. they are applied in the same order as the
+   * array, on request, but reverse order, on response.
+   *
+   * {@link ng.$http#interceptors Interceptors detailed info}
+   */
+  interceptors: any[];
+  /**
+   * Array containing URLs whose origins are trusted to receive the XSRF token. See the
+   * {@link ng.$http#security-considerations Security Considerations} sections for more details on
+   * XSRF.
+   *
+   * **Note:** An "origin" consists of the [URI scheme](https://en.wikipedia.org/wiki/URI_scheme),
+   * the [hostname](https://en.wikipedia.org/wiki/Hostname) and the
+   * [port number](https://en.wikipedia.org/wiki/Port_(computer_networking). For `http:` and
+   * `https:`, the port number can be omitted if using th default ports (80 and 443 respectively).
+   * Examples: `http://example.com`, `https://api.example.com:9876`
+   *
+   * <div class="alert alert-warning">
+   *   It is not possible to trust specific URLs/paths. The `path`, `query` and `fragment` parts
+   *   of a URL will be ignored. For example, `https://foo.com/path/bar?query=baz#fragment` will be
+   *   treated as `https://foo.com`, meaning that **all** requests to URLs starting with
+   *   `https://foo.com/` will include the XSRF token.
+   * </div>
+   *
+   * @example
+   *
+   * ```js
+   * // App served from `https://example.com/`.
+   * angular.
+   *   module('xsrfTrustedOriginsExample', []).
+   *   config(['$httpProvider', function($httpProvider) {
+   *     $httpProvider.xsrfTrustedOrigins.push('https://api.example.com');
+   *   }]).
+   *   run(['$http', function($http) {
+   *     // The XSRF token will be sent.
+   *     $http.get('https://api.example.com/preferences').then(...);
+   *
+   *     // The XSRF token will NOT be sent.
+   *     $http.get('https://stats.example.com/activity').then(...);
+   *   }]);
+   * ```
+   *
+   * @type {string[]}
+   */
+  xsrfTrustedOrigins: string[];
+  $get: (
+    | string
+    | ((
+        $httpBackend: any,
+        $injector: import("../../core/di/internal-injector.js").InjectorService,
+        $sce: any,
+      ) => {
+        (requestConfig: any): Promise<any>;
+        pendingRequests: any[];
+        /**
+         * Runtime equivalent of the `$httpProvider.defaults` property. Allows configuration of
+         * default headers, withCredentials as well as request and response transformations.
+         *
+         * See "Setting HTTP Headers" and "Transforming Requests and Responses" sections above.
+         */
+        defaults: {
+          transformResponse: (typeof defaultHttpResponseTransform)[];
+          transformRequest: ((d: any) => any)[];
+          headers: {
+            common: {
+              Accept: string;
+            };
+            post: any;
+            put: any;
+            patch: any;
+          };
+          xsrfCookieName: string;
+          xsrfHeaderName: string;
+          paramSerializer: string;
+        };
+      })
+  )[];
+}

package/@types/services/http-backend/http-backend.d.ts

@@ -0,0 +1,58 @@
+/**
+ * @returns
+ */
+export function createHttpBackend(): (
+  method: string,
+  url?: string,
+  post?: any,
+  callback?: (
+    arg0: number,
+    arg1: any,
+    arg2: string | null,
+    arg3: string,
+    arg4: string,
+  ) => void,
+  headers?: {
+    [x: string]: string;
+  },
+  timeout?: number | Promise<any>,
+  withCredentials?: boolean,
+  responseType?: XMLHttpRequestResponseType,
+  eventHandlers?: {
+    [x: string]: EventListener;
+  },
+  uploadEventHandlers?: {
+    [x: string]: EventListener;
+  },
+) => void;
+/**
+ * HTTP backend used by the `$http` that delegates to
+ * XMLHttpRequest object and deals with browser incompatibilities.
+ * You should never need to use this service directly.
+ */
+export class HttpBackendProvider {
+  $get: () => (
+    method: string,
+    url?: string,
+    post?: any,
+    callback?: (
+      arg0: number,
+      arg1: any,
+      arg2: string | null,
+      arg3: string,
+      arg4: string,
+    ) => void,
+    headers?: {
+      [x: string]: string;
+    },
+    timeout?: number | Promise<any>,
+    withCredentials?: boolean,
+    responseType?: XMLHttpRequestResponseType,
+    eventHandlers?: {
+      [x: string]: EventListener;
+    },
+    uploadEventHandlers?: {
+      [x: string]: EventListener;
+    },
+  ) => void;
+}