@vcd/sdk 0.13.0 → 15.0.0

package/README.md

@@ -1,119 +1,4 @@
-# vCD API Client #
-A collection of Typescript libraries for quickly and easily communication with a vCloud Director installation via its API.
+# VMware Cloud Director Extensibility
+Please file issues and pull requests against [Cloud Director Extension Standard Library](https://github.com/vmware/cloud-director-extension-standard-library).
 
-## Overview ##
-The API client is currently made up of the following packages:
-
-### @vcd/bindings ###
-A collection of Typescript objects that represent the vCD API's requests/responses.
-
-### @vcd/sdk ###
-An Angular module that provides a REST API client with consistent handling of patterns and behaviors specific to the vCloud REST API. This module also contains various utilities and tools for things like query and filter management.
-
-## Building ##
-### Prerequisites ###
-
-Before the `api-client` packages can be built, the `java/api-schemas` projects must be built. Generation of the Java API bindings is a prerequisite to generating the Typescript bindings because it is these Java classes that drive the binding generation. From the `vcd-ext-sdk` project root directory:
-
-```bash
-cd java
-mvn install
-```
-
-  
-
-Next navigate to the `api-client` folder and generate the bindings. **Note: these steps only need to be performed when the bindings change.**
-
-```bash
-cd ../ui/api-client
-mvn generate-sources
-```
-
-### Install ###
-
-At this point, the Typescript source files will be generated in the bindings package, and the `api-client` project can be treated (more or less) like a traditional Node package. Executing the following 2 commands
-
-```bash
-yarn
-yarn bootstrap
-```
-will initialize the top level project, and then initialize and build `@vcd/bindings` and `@vcd/sdk`.
-
-## Using the SDK ##
-
-Create a new Angular project. [Angular CLI](https://cli.angular.io/) provides a very simple mechanism to get up and running with a new Angular project. Once you have a project, the SDK and bindings can be added with a few simple steps:
-
-### Using ng add @vcd/sdk ###
-1. The same as the 1st **Regular Way** step
-2. `ng add @vcd/sdk`
-3. You will be prompted for the following:
-	3.1 Module name - VcdSdkModule by default
-	3.3 Path to the module where you want to import the package (Optional) - by default your it will be added to your root module, however you can specify a relative path to an specific module.
-
-### Regular Way ###
-
-1. Add `@vcd/bindings` and `@vcd/sdk` as project dependencies
-```json
-// package.json
-{
-
-  "dependencies": {
-  ...,
-  "@vcd/bindings": "<path to api-client/packages/bindings/dist>",
-  "@vcd/sdk": "<path to api-client/packages/sdk/dist>",
-  ...
-  }
-}
-```
-2. Import `VcdSdkModule` into the app module and set `VcdApiClient` as a provider
-```js
-@NgModule({
-  declarations: [
-    AppComponent
-  ],
-  imports: [
-    BrowserModule,
-    VcdSdkModule
-  ],
-  providers: [VcdApiClient],
-  bootstrap: [AppComponent]
-})
-
-export  class  AppModule { }
-
-```
-3. Inject `VcdApiClient` into a component
-```js
-
-constructor(private  client: VcdApiClient) {}
-
-```
-The SDK is now ready for use.
-
-### Usage examples ###
-#### Authenticating ####
-If you don't have an existing session, you can create one:
-```js
-ngOnInit(): void {
-this.client.login('username', 'org', 'pa$$w0rd').subscribe(() => {
-console.log(`logged into ${this.client.organization} as ${this.client.username}`);
-});
-```
-
-If you already have an existing session (because you're acting as a UI extension and have access to the authentication token for example) you can simply set the authentication of the client instance to use the Bearer token:
-```js
-ngOnInit(): void {
-this.client.setAuthentication(bearerToken).subscribe(() => {
-console.log(`logged into ${this.client.organization} as ${this.client.username}`);
-});
-```
-
-#### Querying the API ####
-The query builder can be used to quickly create API calls that are compatible with the query service:
-```js
-this.client.query(Query.Builder.ofType('virtualCenter'))).pipe(
-
-tap(queryResult  =>  console.log(`Virtual centers: ${queryResult.total}`))
-
-).subscribe();
-```
+Usage information and reference details can be found in [Cloud Director Extension Standard Library](https://github.com/vmware/cloud-director-extension-standard-library) documentation.

package/client/client/api.result.service.d.ts

@@ -0,0 +1,20 @@
+import * as i0 from "@angular/core";
+export declare class ApiResultService {
+    private _results;
+    get results(): ApiResult[];
+    add(result: ApiResult): void;
+    clear(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApiResultService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ApiResultService>;
+}
+export declare class ApiResult {
+    private _message;
+    get message(): string;
+    private _succeeded;
+    get succeeded(): boolean;
+    private _started;
+    get started(): Date;
+    private _finished;
+    get finished(): Date;
+    constructor(message: string, succeeded: boolean, started: Date, finished: Date);
+}

package/client/client/constants.d.ts

@@ -0,0 +1,10 @@
+/**
+ * HTTP Headers
+ */
+export declare const HTTP_HEADERS: Readonly<{
+    Authorization: "Authorization";
+    etag: "etag";
+    link: "link";
+    Link: "Link";
+    x_vcloud_authorization: "x-vcloud-authorization";
+}>;

package/client/client/index.d.ts

@@ -0,0 +1,7 @@
+export * from './api.result.service';
+export * from './vcd.http.client';
+export * from './vcd.api.client';
+export * from './vcd.transfer.client';
+export * from './request.headers.interceptor';
+export * from './logging.interceptor';
+export * from './response.normalization.interceptor';

package/client/client/logging.interceptor.d.ts

@@ -0,0 +1,14 @@
+import { HttpEvent, HttpInterceptor, HttpHandler, HttpRequest } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { ApiResultService } from './api.result.service';
+import * as i0 from "@angular/core";
+export declare class LoggingInterceptor implements HttpInterceptor {
+    private apiResultService;
+    private _outputToConsole;
+    private _enabled;
+    set enabled(enabled: boolean);
+    constructor(apiResultService: ApiResultService);
+    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoggingInterceptor, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LoggingInterceptor>;
+}

package/client/client/request.headers.interceptor.d.ts

@@ -0,0 +1,20 @@
+import { HttpHandler, HttpInterceptor, HttpRequest, HttpEvent } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class RequestHeadersInterceptor implements HttpInterceptor {
+    private _enabled;
+    set enabled(_enabled: boolean);
+    private _actAs;
+    set actAs(_actAs: string);
+    private _version;
+    get version(): string;
+    set version(_version: string);
+    private _authenticationHeader;
+    private _authentication;
+    set authentication(_authentication: string);
+    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    private setAcceptHeader;
+    private setContentTypeHeader;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RequestHeadersInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RequestHeadersInterceptor>;
+}

package/client/client/response.normalization.interceptor.d.ts

@@ -0,0 +1,39 @@
+import { HttpEvent, HttpInterceptor, HttpHandler, HttpRequest } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * An interceptor on the response chain that normalizes differences in
+ * JSON payloads between vCloud Director version 9.1 and versions
+ * greater than 9.1.
+ *
+ * In 9.1 (API version 30.0) the server serializes JSON and nests the payload in a value field:
+ * ```
+  {
+    "name" : "{http://www.vmware.com/vcloud/versions}SupportedVersions",
+    "declaredType" : "com.vmware.vcloud.api.rest.schema.versioning.SupportedVersionsType",
+    "scope" : "javax.xml.bind.JAXBElement$GlobalScope",
+    "value" : {
+      "versionInfo" : [],
+      "any" : [],
+      "otherAttributes" : {}
+    }
+  }
+  ```
+ *
+ * That same request in API versions 31.0 and above is represented as:
+ * ```
+  {
+    "versionInfo" : [],
+    "any" : [],
+    "otherAttributes" : {}
+  }
+  ```
+ * This interceptor should process responses before any other interceptors that rely
+ * on consistent API information.
+ */
+export declare class ResponseNormalizationInterceptor implements HttpInterceptor {
+    private static readonly QUERY_RESULT_TYPE;
+    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResponseNormalizationInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResponseNormalizationInterceptor>;
+}

package/client/client/vcd.api.client.d.ts

@@ -0,0 +1,351 @@
+import { Injector } from '@angular/core';
+import { HttpHeaders } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { SessionType, AuthorizedLocationType, ResourceType, LinkType, EntityReferenceType, TaskType } from '@vcd/bindings/vcloud/api/rest/schema_v1_5';
+import { AccessibleLocation, Session } from '../openapi';
+import { Query } from '../query/index';
+import { VcdHttpClient } from './vcd.http.client';
+import { VcdTransferClient } from './vcd.transfer.client';
+import { VcdSdkConfig } from "../../core/plugin.module";
+import * as i0 from "@angular/core";
+export declare const TRANSFER_LINK_REL = "upload:default";
+export type Navigable = ResourceType | {
+    link?: LinkType[];
+};
+export declare const HATEOAS_HEADER = "Link";
+/**
+ * Parse out Link headers using a very lazily implemented pull parser
+ * @param header '<url1>;name1="value1",name2="value2",<url2>;name3="value3,value4"'
+ * @returns parsed link headers
+ */
+export declare function parseHeaderHateoasLinks(header: string): LinkType[];
+export declare enum LinkRelType {
+    add = "add",
+    remove = "remove",
+    edit = "edit"
+}
+/**
+ * A basic client for interacting with the VMware Cloud Director APIs.
+ *
+ * A VMware Cloud Director plugin can get a reference to this client by using angular injection.
+ * ```
+ *     constructor(private vcdApi: VcdApiClient) {}
+ * ```
+ *
+ * VcdApiClient reuses the authentication from the VCD platform so in general there is
+ * no need of an explicit authentication/login.
+ *
+ * When dealing with the session management there are two APIs:
+ * 1. Deprecated legacy API that is using the `api/session` endpoint and the corresponding models
+ * 2. Newly added API that is using the `cloudapi` endpoint and the corresponding models
+ *
+ * Note that if a plugin performs an explicit cloud api authentication call through
+ * {@link VcdApiClient#setCloudApiAuthentication} or {@link VcdApiClient#cloudApiLogin}
+ * from that moment on the VcdApiClient uses only cloud api session management.
+ * This means calls to {@link VcdApiClient#setAuthentication} or {@link VcdApiClient#login} have no effect.
+ */
+export declare class VcdApiClient {
+    private http;
+    private injector;
+    private config?;
+    set baseUrl(_baseUrl: string);
+    get version(): string;
+    private _negotiateVersion;
+    private _baseUrl;
+    /**
+     * @deprecated Use {@link VcdApiClient#_cloudApiSession}
+     */
+    private _session;
+    private _sessionObservable;
+    private _getSession;
+    /**
+     * CloudApi Session
+     */
+    private _cloudApiSession;
+    private _cloudApiSessionObservable;
+    /**
+     * This observable has a special purpose when doing automatic login during the constructor initialization.
+     * It allows backend call only after an API version is set.
+     * It also ensures that a backend call to get the current session is done once prior to any other calls.
+     *
+     * In case of an explicit cloud api auth request there is no need of this observable
+     * since this auth request will retrieve the session itself
+     */
+    private _getCloudApiSession;
+    private _cloudApiSessionLinks;
+    /**
+     * Cached, lazy loaded observable of the AccessibleLocation array
+     */
+    private _cloudApiAccessibleLocations;
+    /**
+     * This property determines if it is an explicit cloud api login.
+     * In this case the old API (/api/session) should not be used at all.
+     */
+    private _isCloudApiLogin;
+    constructor(http: VcdHttpClient, injector: Injector, config?: VcdSdkConfig);
+    private negotiateVersion;
+    /**
+     * The purpose of this function is to ensure that prior to sending any call to the backend
+     * the version has been set and the current session has been retrieved.
+     * Note that this is important during the automatic authentication that is done during the
+     * constructor initialization, when the plugin is not required to perform its own explicit authentication
+     * but rather the ones from the underlying framework is used.
+     */
+    private validateRequestContext;
+    /**
+     *
+     * For use cases wich solely depends on cloudapi without any backward compatibility
+     * there should be no dependence on the old /api endpoint at all
+     */
+    private validateRequestContextCloudApiOnly;
+    setVersion(_version: string): VcdApiClient;
+    /**
+     * Global configuration for the service, that allows a provider user to execute API requests
+     * in the scope of a specific tenant.
+     *
+     * If you want to execute single API request in scope of specific tenant you can do it
+     * by passing "X-VMWARE-VCLOUD-TENANT-CONTEXT" header to the specific API Request.
+     *
+     * This scoping is available to query-based API calls and to bulk GET calls in the
+     * /cloudapi space.
+     *
+     * @param actAs an entityRef of the tenant (organization) to scope subsequent calls to in
+     *  the VcdApiClient, or null/no parameter to remove tenant-specific scoping
+     * @returns the current VcdApiClient instance (for chaining)
+     */
+    actAs(actAs?: EntityReferenceType): VcdApiClient;
+    /**
+     * @deprecated Use {@link VcdApiClient#setCloudApiAuthentication}
+     *
+     * Sets the authentication token to use for the VcdApiClient.
+     *
+     * After setting the token, the client will get the current session
+     * information associated with the authenticated token.
+     *
+     * @param authentication the authentication string (to be used in either the 'Authorization'
+     *  or 'x-vcloud-authorization' header)
+     * @returns the session associated with the authentication token
+     */
+    setAuthentication(authentication: string): Observable<SessionType>;
+    /**
+     * Sets the authentication token to use for the VcdApiClient.
+     *
+     * After setting the token, the client will get the current session
+     * information associated with the authenticated token.
+     *
+     * @param authentication the authentication string (to be used in either the 'Authorization'
+     *  or 'x-vcloud-authorization' header)
+     *
+     * @returns session observable associated with the authentication token
+     */
+    setCloudApiAuthentication(authentication: string): Observable<Session>;
+    enableLogging(): VcdApiClient;
+    /**
+     * @deprecated Use {@link VcdApiClient#cloudApiLogin}
+     *
+     * Creates an authenticated session for the specified credential data.
+     *
+     * @param username the name of the user to authenticate
+     * @param tenant the organization the user belongs to
+     * @param password the password for the user
+     * @returns an authenticated session for the given credentials
+     */
+    login(username: string, tenant: string, password: string): Observable<SessionType>;
+    /**
+     * Creates an authenticated session for the specified credential data using cloud api endpoint.
+     *
+     * @param username the name of the user to authenticate
+     * @param tenant the organization the user belongs to
+     * @param password the password for the user
+     * @returns an authenticated session for the given credentials
+     */
+    cloudApiLogin(username: string, tenant: string, password: string): Observable<Session>;
+    /**
+     * It is necessary to know if an explicit cloud api auth request was done.
+     * This function handles this by setting the corresponding flags, properties etc.
+     */
+    private onBeforeCloudApiAuthentication;
+    /**
+     * Handle authentication.
+     * This includes getting HATEOAS links, setting the session, handling errors etc.
+     */
+    private onCloudApiAuthentication;
+    private onCloudApiAuthenticationError;
+    private setCloudApiSessionLinks;
+    get<T>(endpoint: string, options?: {
+        headers?: HttpHeaders;
+    }): Observable<T>;
+    list<T>(endpoint: string, queryBuilder?: Query.Builder, multisite?: boolean | AuthorizedLocationType[], options?: {
+        headers?: HttpHeaders;
+    }): Observable<T>;
+    createSync<T>(endpoint: string, item: T, options?: {
+        headers?: HttpHeaders;
+    }): Observable<T>;
+    createAsync<T>(endpoint: string, item: T, options?: {
+        headers?: HttpHeaders;
+    }): Observable<TaskType>;
+    getTransferLink<T>(endpoint: string, item: T, transferRel?: string): Observable<string>;
+    startTransfer<T>(endpoint: string, item: T, transferRel?: string): Observable<VcdTransferClient>;
+    updateSync<T>(endpoint: string, item: T, options?: {
+        headers?: HttpHeaders;
+    }): Observable<T>;
+    updateAsync<T>(endpoint: string, item: T, options?: {
+        headers?: HttpHeaders;
+    }): Observable<TaskType>;
+    deleteSync(endpoint: string, options?: {
+        headers?: HttpHeaders;
+    }): Observable<void>;
+    deleteAsync(endpoint: string, options?: {
+        headers?: HttpHeaders;
+    }): Observable<TaskType>;
+    private mapResponseToTask;
+    getEntity<T extends EntityReferenceType>(entityRef: EntityReferenceType): Observable<T>;
+    getEntity<T extends EntityReferenceType>(urn: string): Observable<T>;
+    updateTask(task: TaskType, options?: {
+        headers?: HttpHeaders;
+    }): Observable<TaskType>;
+    isTaskComplete(task: TaskType): boolean;
+    removeItem(item: Navigable, options?: {
+        headers?: HttpHeaders;
+    }): Observable<TaskType>;
+    /**
+     * Queries the VMware Cloud Director API based on the specified Query.Builder instance.
+     *
+     * @param builder An definition of the query to construct (type, filter, page size, etc.)
+     * @param multisite a flag indicating whether or not to fan the query out to all available sites
+     * @returns a query result for the specified query
+     */
+    query<T>(builder: Query.Builder, multisite?: boolean, options?: {
+        headers?: HttpHeaders;
+    }): Observable<T>;
+    /**
+     * Queries the VMware Cloud Director API based on the specified Query.Builder instance.
+     *
+     * @param builder An definition of the query to construct (type, filter, page size, etc.)
+     * @param multisite the set of site locations to include in the query fanout
+     * @returns a query result for the specified query
+     */
+    query<T>(builder: Query.Builder, multisite?: AuthorizedLocationType[], options?: {
+        headers?: HttpHeaders;
+    }): Observable<T>;
+    /**
+     * Queries the VMware Cloud Director API for the first page of the provided result set.
+     *
+     * @param result the result set to retrieve the first page of records for
+     * @param multisite a flag indicating whether or not to fan the query out to all available sites
+     * @returns the records for the first page of the query
+     */
+    firstPage<T>(result: T, multisite?: boolean, options?: {
+        headers?: HttpHeaders;
+    }): Observable<T>;
+    /**
+     * Queries the VMware Cloud Director API for the first page of the provided result set.
+     *
+     * @param result the result set to retrieve the first page of records for
+     * @param multisite the set of site locations to include in the query fanout
+     * @returns the records for the first page of the query
+     */
+    firstPage<T>(result: T, multisite?: AuthorizedLocationType[], options?: {
+        headers?: HttpHeaders;
+    }): Observable<T>;
+    hasFirstPage<T>(result: T): boolean;
+    /**
+     * Queries the VMware Cloud Director API for the previous page of the provided result set.
+     *
+     * @param result the result set to retrieve the previous page of records for
+     * @param multisite a flag indicating whether or not to fan the query out to all available sites
+     * @returns the records for the previous page of the query
+     */
+    previousPage<T>(result: T, multisite?: boolean, options?: {
+        headers?: HttpHeaders;
+    }): Observable<T>;
+    /**
+     * Queries the VMware Cloud Director API for the previous page of the provided result set.
+     *
+     * @param result the result set to retrieve the previous page of records for
+     * @param multisite the set of site locations to include in the query fanout
+     * @returns the records for the previous page of the query
+     */
+    previousPage<T>(result: T, multisite?: AuthorizedLocationType[], options?: {
+        headers?: HttpHeaders;
+    }): Observable<T>;
+    hasPreviousPage<T>(result: T): boolean;
+    /**
+     * Queries the VMware Cloud Director API for the next page of the provided result set.
+     *
+     * @param result the result set to retrieve the next page of records for
+     * @param multisite a flag indicating whether or not to fan the query out to all available sites
+     * @returns the records for the next page of the query
+     */
+    nextPage<T>(result: T, multisite?: boolean, options?: {
+        headers?: HttpHeaders;
+    }): Observable<T>;
+    /**
+     * Queries the VMware Cloud Director API for the next page of the provided result set.
+     *
+     * @param result the result set to retrieve the next page of records for
+     * @param multisite the set of site locations to include in the query fanout
+     * @returns the records for the next page of the query
+     */
+    nextPage<T>(result: T, multisite?: AuthorizedLocationType[], options?: {
+        headers?: HttpHeaders;
+    }): Observable<T>;
+    hasNextPage<T>(result: T): boolean;
+    /**
+     * Queries the VMware Cloud Director API for the last page of the provided result set.
+     *
+     * @param result the result set to retrieve the last page of records for
+     * @param multisite a flag indicating whether or not to fan the query out to all available sites
+     * @returns the records for the last page of the query
+     */
+    lastPage<T>(result: T, multisite?: boolean, options?: {
+        headers?: HttpHeaders;
+    }): Observable<T>;
+    /**
+     * Queries the VMware Cloud Director API for the last page of the provided result set.
+     *
+     * @param result the result set to retrieve the last page of records for
+     * @param multisite the set of site locations to include in the query fanout
+     * @returns the records for the last page of the query
+     */
+    lastPage<T>(result: T, multisite?: AuthorizedLocationType[], options?: {
+        headers?: HttpHeaders;
+    }): Observable<T>;
+    hasLastPage<T>(result: T): boolean;
+    private getQueryPage;
+    /**
+     * Use to perform action availability check before calling the API
+     * @param item - the navigable item (containing link collection)
+     * @param linkRelType - the link rel type, pass either LinkRelType or string
+     * @param entityRefType - the entity reference type
+     */
+    canPerformAction(item: Navigable, linkRelType: LinkRelType | string, entityRefType?: string): boolean;
+    private findLink;
+    private parseMultisiteValue;
+    /**
+     * @deprecated Use cloudApiSession
+     */
+    get session(): Observable<SessionType>;
+    /**
+     * Get Session observable
+     */
+    get cloudApiSession(): Observable<Session>;
+    get username(): Observable<string>;
+    get organization(): Observable<string>;
+    /**
+     * @deprecated Use cloudApiLocation
+     */
+    get location(): Observable<AuthorizedLocationType>;
+    /**
+     * Gets the location corresponding to the current session
+     */
+    get cloudApiLocation(): Observable<AccessibleLocation>;
+    getLocation(session: SessionType): AuthorizedLocationType;
+    /**
+     * Build the endpoint url. If the provided endpoint is already an absolute URL, then return it as it is without
+     * any modifications, otherwise consider it as a relative one and prepend the baseUrl as defined by the host application.
+     */
+    private buildEndpointUrl;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VcdApiClient, [null, null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<VcdApiClient>;
+}

package/client/client/vcd.http.client.d.ts

@@ -0,0 +1,32 @@
+import { HttpBackend, HttpClient } from '@angular/common/http';
+import { LoggingInterceptor } from './logging.interceptor';
+import { RequestHeadersInterceptor } from './request.headers.interceptor';
+import { ResponseNormalizationInterceptor } from './response.normalization.interceptor';
+import * as i0 from "@angular/core";
+/**
+ * This is a specialist subclass of HttpClient.  The HttpClient that is defined/imported
+ * by HttpClientModule is a singleton from the container, meaning that all extensions would
+ * get the same one.  We sub-class it so that each extension gets their own instance.
+ * Extension consumers should inject this.
+ * @see HttpClient
+ */
+export declare class VcdHttpClient extends HttpClient {
+    /**
+     * Provide access to the logging interceptor for enabling/disabling and configuring.
+     */
+    readonly loggingInterceptor: LoggingInterceptor;
+    /**
+     * Provide access to the headers interceptor for enabling/disabling and configuring.
+     */
+    readonly requestHeadersInterceptor: RequestHeadersInterceptor;
+    /**
+     * Create an HttpClient with the logging and header interceptors in the chain.
+     * @param httpBackend backend (likely injected from HttpClientModule)
+     * @param hateoasHeaderInterceptor the hateoas header interceptor
+     * @param loggingInterceptor the logging interceptor
+     * @param requestHeadersInterceptor the request header interceptor
+     */
+    constructor(httpBackend: HttpBackend, loggingInterceptor: LoggingInterceptor, requestHeadersInterceptor: RequestHeadersInterceptor, responseNormalizationInterceptor: ResponseNormalizationInterceptor);
+    static ɵfac: i0.ɵɵFactoryDeclaration<VcdHttpClient, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<VcdHttpClient>;
+}