D-Net

import { Observable } from 'rxjs/Observable';

import { RequestOptions } from './base_request_options';

import { ConnectionBackend, RequestOptionsArgs } from './interfaces';

import { Request } from './static_request';

import { Response } from './static_response';

/**

 * Performs http requests using `XMLHttpRequest` as the default backend.

 *

 * `Http` is available as an injectable class, with methods to perform http requests. Calling

 * `request` returns an `Observable` which will emit a single {@link Response} when a

 * response is received.

 *

 * ### Example

 *

 * ```typescript

 * import {Http, HTTP_PROVIDERS} from '@angular/http';

 * import 'rxjs/add/operator/map'

 * @Component({

 *   selector: 'http-app',

 *   viewProviders: [HTTP_PROVIDERS],

 *   templateUrl: 'people.html'

 * })

 * class PeopleComponent {

 *   constructor(http: Http) {

 *     http.get('people.json')

 *       // Call map on the response observable to get the parsed people object

 *       .map(res => res.json())

 *       // Subscribe to the observable to get the parsed people object and attach it to the

 *       // component

 *       .subscribe(people => this.people = people);

 *   }

 * }

 * ```

 *

 *

 * ### Example

 *

 * ```

 * http.get('people.json').subscribe((res:Response) => this.people = res.json());

 * ```

 *

 * The default construct used to perform requests, `XMLHttpRequest`, is abstracted as a "Backend" (

 * {@link XHRBackend} in this case), which could be mocked with dependency injection by replacing

 * the {@link XHRBackend} provider, as in the following example:

 *

 * ### Example

 *

 * ```typescript

 * import {BaseRequestOptions, Http} from '@angular/http';

 * import {MockBackend} from '@angular/http/testing';

 * var injector = Injector.resolveAndCreate([

 *   BaseRequestOptions,

 *   MockBackend,

 *   {provide: Http, useFactory:

 *       function(backend, defaultOptions) {

 *         return new Http(backend, defaultOptions);

 *       },

 *       deps: [MockBackend, BaseRequestOptions]}

 * ]);

 * var http = injector.get(Http);

 * http.get('request-from-mock-backend.json').subscribe((res:Response) => doSomething(res));

 * ```

 *

 * @experimental

 */

export declare class Http {

    protected _backend: ConnectionBackend;

    protected _defaultOptions: RequestOptions;

    constructor(_backend: ConnectionBackend, _defaultOptions: RequestOptions);

    /**

     * Performs any type of http request. First argument is required, and can either be a url or

     * a {@link Request} instance. If the first argument is a url, an optional {@link RequestOptions}

     * object can be provided as the 2nd argument. The options object will be merged with the values

     * of {@link BaseRequestOptions} before performing the request.

     */

    request(url: string | Request, options?: RequestOptionsArgs): Observable<Response>;

    /**

     * Performs a request with `get` http method.

     */

    get(url: string, options?: RequestOptionsArgs): Observable<Response>;

    /**

     * Performs a request with `post` http method.

     */

    post(url: string, body: any, options?: RequestOptionsArgs): Observable<Response>;

    /**

     * Performs a request with `put` http method.

     */

    put(url: string, body: any, options?: RequestOptionsArgs): Observable<Response>;

    /**

     * Performs a request with `delete` http method.

     */

    delete(url: string, options?: RequestOptionsArgs): Observable<Response>;

    /**

     * Performs a request with `patch` http method.

     */

    patch(url: string, body: any, options?: RequestOptionsArgs): Observable<Response>;

    /**

     * Performs a request with `head` http method.

     */

    head(url: string, options?: RequestOptionsArgs): Observable<Response>;

    /**

     * Performs a request with `options` http method.

     */

    options(url: string, options?: RequestOptionsArgs): Observable<Response>;

}

/**

 * @experimental

 */

export declare class Jsonp extends Http {

    constructor(backend: ConnectionBackend, defaultOptions: RequestOptions);

    /**

     * Performs any type of http request. First argument is required, and can either be a url or

     * a {@link Request} instance. If the first argument is a url, an optional {@link RequestOptions}

     * object can be provided as the 2nd argument. The options object will be merged with the values

     * of {@link BaseRequestOptions} before performing the request.

     *

     * @security Regular XHR is the safest alternative to JSONP for most applications, and is

     * supported by all current browsers. Because JSONP creates a `<script>` element with

     * contents retrieved from a remote source, attacker-controlled data introduced by an untrusted

     * source could expose your application to XSS risks. Data exposed by JSONP may also be

     * readable by malicious third-party websites. In addition, JSONP introduces potential risk for

     * future security issues (e.g. content sniffing).  For more detail, see the

     * [Security Guide](http://g.co/ng/security).

     */

    request(url: string | Request, options?: RequestOptionsArgs): Observable<Response>;

}