@vcd/sdk 0.13.0 → 15.0.0-alpha.0

package/client/index.d.ts

@@ -0,0 +1,2 @@
+export * from './query';
+export * from './client';

package/client/openapi.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Entity reference used to describe VCD entities
+ */
+export declare class EntityReference {
+    'name': string;
+    'id': string;
+}
+/**
+ * Session
+ */
+export declare class Session {
+    /**
+     * ID of session
+     */
+    'id': string;
+    /**
+     * User of this session
+     */
+    'user': EntityReference;
+    /**
+     * Organization user is logged into for this session
+     */
+    'org': EntityReference;
+    /**
+     * The accessible location this session is valid for
+     */
+    'location': string;
+    /**
+     * User's roles for this session
+     */
+    'roles': Array<string>;
+    /**
+     * References to user's roles
+     */
+    'roleRefs': Array<EntityReference>;
+    /**
+     * The session idle timeout in minutes
+     */
+    'sessionIdleTimeoutMinutes': number;
+}
+/**
+ * A list of locations accessible to this session.
+ */
+export interface AccessibleLocations {
+    /**
+     * How many results there are in total (i.e., considering all pages).
+     */
+    resultTotal?: number;
+    /**
+     * How many pages there are in total.
+     */
+    pageCount?: number;
+    /**
+     * The page that was fetched, 1-indexed.
+     */
+    page?: number;
+    /**
+     * Result count for page that was fetched.
+     */
+    pageSize?: number;
+    /**
+     * The current page of accessible locations.
+     */
+    values?: Array<AccessibleLocation>;
+}
+/**
+ * A location accessible to this session.
+ */
+export declare class AccessibleLocation {
+    'locationId': string;
+    'site': EntityReference;
+    'org': EntityReference;
+    'restApiEndpoint': string;
+    'uiEndpoint': string;
+    'apiVersion': string;
+}

package/client/query/filter.builder.d.ts

@@ -0,0 +1,162 @@
+export declare namespace Filter {
+    /**
+     * Collection of strategies for wilcard string matching.
+     */
+    class MatchMode {
+        /**
+         * Match the start of a string.
+         */
+        static readonly START: string;
+        /**
+         * Match the end of a string.
+         */
+        static readonly END: string;
+        /**
+         * Match anywhere in the string.
+         */
+        static readonly ANYWHERE: string;
+    }
+    /**
+     * A filter item that can define a comparison/condition.
+     */
+    interface Property {
+        /**
+         * Create a filter condition to evaluate whether the property is equal to the specified value.
+         *
+         * @param value the pattern to evaluate
+         * @param moreValues optional additional patterns to evaluate that will be treated as an OR condition
+         * @returns an evaluatable filter condition
+         */
+        equalTo(value: (boolean | number | string), ...moreValues: (boolean | number | string)[]): CompleteCondition;
+        /**
+         * Create a filter condition to evaluate whether the property is not equal to the specified value.
+         *
+         * @param value the pattern to evaluate
+         * @returns an evaluatable filter condition
+         */
+        notEqualTo(value: (boolean | number | string)): CompleteCondition;
+        /**
+         * Create a filter condition to evaluate whether the property is less than the specified value.
+         *
+         * @param value the pattern to evaluate
+         * @returns an evaluatable filter condition
+         */
+        lessThan(value: number): CompleteCondition;
+        /**
+         * Create a filter condition to evaluate whether the property is less than or equal to the specified value.
+         *
+         * @param value the pattern to evaluate
+         * @returns an evaluatable filter condition
+         */
+        lessOrEqualTo(value: number): CompleteCondition;
+        /**
+         * Create a filter condition to evaluate whether the property is greater than the specified value.
+         *
+         * @param value the pattern to evaluate
+         * @returns an evaluatable filter condition
+         */
+        greaterThan(value: number): CompleteCondition;
+        /**
+         * Create a filter condition to evaluate whether the property is greater than or equal to the specified value.
+         *
+         * @param value the pattern to evaluate
+         * @returns an evaluatable filter condition
+         */
+        greaterOrEqualTo(value: number): CompleteCondition;
+        /**
+         * Create a filter condition to evaluate whether the property is a wildcard match with the specified value.
+         *
+         * @param value the pattern to evaluate
+         * @param mode the type of wildcard evaluation to perform
+         * @returns an evaluatable filter condition
+         */
+        like(value: string, mode: MatchMode): CompleteCondition;
+    }
+    /**
+     * A representation of a condition that is incomplete by itself, like an empty condition, aggregation wrapper, or junction.
+     */
+    interface PartialCondition {
+        /**
+         * Create a simple property to be evaulated as a filter condition.
+         *
+         * @param property the name of the property
+         * @returns a Property instance for defining a filter condition
+         */
+        is(property: string): Property;
+        /**
+         * Create a conjunction (AND) condition from existing conditions.
+         *
+         * @param condition1 first condition
+         * @param condition2 second condition
+         * @param conditionN any additional conditions
+         * @returns an evaluatable filter condition
+         */
+        and(condition1: CompleteCondition, condition2: CompleteCondition, conditionN?: CompleteCondition[]): CompleteCondition;
+        /**
+         * Create a disjunction (OR) condition from existing conditions.
+         *
+         * @param condition1 first condition
+         * @param condition2 second condition
+         * @param conditionN any additional conditions
+         * @returns an evaluatable filter condition
+         */
+        or(condition1: CompleteCondition, condition2: CompleteCondition, conditionN?: CompleteCondition[]): CompleteCondition;
+    }
+    /**
+     * An evaluatable filter condition.
+     */
+    interface CompleteCondition {
+        /**
+         * Add a condtion to this condition.
+         *
+         * This new condition will be ANDed to the existing condition.
+         *
+         * @returns an incomplete (empty) condition
+         */
+        and(): PartialCondition;
+        /**
+         * Add a condtion to this condition.
+         *
+         * This new condition will be ORed to the existing condition.
+         *
+         * @returns an incomplete (empty) condition
+         */
+        or(): PartialCondition;
+        /**
+         * Build the FIQL representation of the condition.
+         *
+         * @returns a FIQL string
+         */
+        query(): string;
+    }
+    /**
+     * Builds a FIQL search condition using a fluent interface.
+     */
+    class Builder implements PartialCondition {
+        /**
+         * Create a simple property to be evaulated as a filter condition.
+         *
+         * @param property the name of the property
+         * @returns a Property instance for defining a filter condition
+         */
+        is(property: string): Property;
+        /**
+         * Create a conjunction (AND) condition from existing conditions.
+         *
+         * @param condition1 first condition
+         * @param condition2 second condition
+         * @param conditionN any additional conditions
+         * @returns an evaluatable filter condition
+         */
+        and(condition1: CompleteCondition, condition2: CompleteCondition, conditionN?: CompleteCondition[]): CompleteCondition;
+        /**
+         * Create a disjunction (OR) condition from existing conditions.
+         *
+         * @param condition1 first condition
+         * @param condition2 second condition
+         * @param conditionN any additional conditions
+         * @returns an evaluatable filter condition
+         */
+        or(condition1: CompleteCondition, condition2: CompleteCondition, conditionN?: CompleteCondition[]): CompleteCondition;
+    }
+}

package/client/query/index.d.ts

@@ -0,0 +1,2 @@
+export * from './query.builder';
+export * from './filter.builder';

package/client/query/query.builder.d.ts

@@ -0,0 +1,30 @@
+export declare namespace Query {
+    class Builder {
+        private _type;
+        private _format;
+        private _links;
+        private _pageSize;
+        private _fields;
+        private _filter;
+        private _sort;
+        private constructor();
+        static getBuilder(): Builder;
+        static ofType(type: string): Builder;
+        format(format: Query.Format): Builder;
+        links(links: boolean): Builder;
+        pageSize(pageSize: number): Builder;
+        fields(...fields: string[]): Builder;
+        filter(filter: string): Builder;
+        sort(...sort: {
+            field: string;
+            reverse?: boolean;
+        }[]): Builder;
+        get(): string;
+        getCloudAPI(): string;
+    }
+    class Format {
+        static readonly ID_RECORDS: string;
+        static readonly RECORDS: string;
+        static readonly REFERENCES: string;
+    }
+}

package/common/container-hooks.d.ts

@@ -67,7 +67,7 @@ export interface ExtensionNavRegistrationAction {
     payload: ExtensionNavRegistration;
     readonly type: string;
 }
-export declare type ExtensionNavRegistrationActionCtor = new (payload: ExtensionNavRegistration) => ExtensionNavRegistrationAction;
+export type ExtensionNavRegistrationActionCtor = new (payload: ExtensionNavRegistration) => ExtensionNavRegistrationAction;
 export declare const ExtensionNavRegistrationAction: ExtensionNavRegistrationActionCtor;
 /**
  * Inject this to access the authentication token.
@@ -118,7 +118,7 @@ export interface EntityActionExtensionSubmenu {
 /**
  * This represents menu information for an entity action.
  */
-export declare type EntityActionExtensionMenuEntry = EntityActionExtensionMenuItem | EntityActionExtensionSubmenu;
+export type EntityActionExtensionMenuEntry = EntityActionExtensionMenuItem | EntityActionExtensionSubmenu;
 /**
  * Every component referenced by an entity action extension point must inherit from this.
  */

package/core/plugin.module.d.ts

@@ -1,11 +1,16 @@
 import { Store } from '@ngrx/store';
 import { ExtensionNavRegistration } from '../common';
-import { TranslateService } from '../i18n';
 export declare class PluginModule {
     private appStore;
-    private translate;
-    constructor(appStore: Store<any>, translate?: TranslateService);
+    constructor(appStore: Store<any>);
     protected registerExtension(extension: ExtensionNavRegistration): void;
-    protected getDefaultLanguage(): string;
-    protected getSupportedLanguages(): string[];
+}
+/**
+ * Config object that is passed on VcdSdkModule init
+ * using .forRoot() method. It can be used to store
+ * configutration properties that are later used by the Services
+ * provided.
+ */
+export declare class VcdSdkConfig {
+    apiVersion: string;
 }

package/esm2020/client/client/api.result.service.mjs

@@ -0,0 +1,43 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+// tslint:disable:variable-name
+export class ApiResultService {
+    constructor() {
+        this._results = [];
+    }
+    get results() {
+        return this._results;
+    }
+    add(result) {
+        this._results = [result, ...this._results.slice(0, 99)];
+    }
+    clear() {
+        this._results = [];
+    }
+}
+ApiResultService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: ApiResultService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ApiResultService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: ApiResultService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: ApiResultService, decorators: [{
+            type: Injectable
+        }] });
+export class ApiResult {
+    get message() {
+        return this._message;
+    }
+    get succeeded() {
+        return this._succeeded;
+    }
+    get started() {
+        return this._started;
+    }
+    get finished() {
+        return this._finished;
+    }
+    constructor(message, succeeded, started, finished) {
+        this._message = message;
+        this._succeeded = succeeded;
+        this._started = started;
+        this._finished = finished;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/client/client/constants.mjs

@@ -0,0 +1,13 @@
+/**
+ * HTTP Headers
+ */
+export const HTTP_HEADERS = Object.freeze({
+    Authorization: 'Authorization',
+    etag: 'etag',
+    // Angular is dealing with case sensitive links despite the specification
+    // https://github.com/angular/angular/issues/6142
+    link: 'link',
+    Link: 'Link',
+    x_vcloud_authorization: 'x-vcloud-authorization'
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdmNkL3Nkay9zcmMvY2xpZW50L2NsaWVudC9jb25zdGFudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFDSCxNQUFNLENBQUMsTUFBTSxZQUFZLEdBQUcsTUFBTSxDQUFDLE1BQU0sQ0FBQztJQUV0QyxhQUFhLEVBQUUsZUFBZTtJQUU5QixJQUFJLEVBQUUsTUFBTTtJQUVaLHlFQUF5RTtJQUN6RSxpREFBaUQ7SUFDakQsSUFBSSxFQUFFLE1BQU07SUFDWixJQUFJLEVBQUUsTUFBTTtJQUVaLHNCQUFzQixFQUFFLHdCQUF3QjtDQUNuRCxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEhUVFAgSGVhZGVyc1xuICovXG5leHBvcnQgY29uc3QgSFRUUF9IRUFERVJTID0gT2JqZWN0LmZyZWV6ZSh7XG5cbiAgICBBdXRob3JpemF0aW9uOiAnQXV0aG9yaXphdGlvbicsXG5cbiAgICBldGFnOiAnZXRhZycsXG5cbiAgICAvLyBBbmd1bGFyIGlzIGRlYWxpbmcgd2l0aCBjYXNlIHNlbnNpdGl2ZSBsaW5rcyBkZXNwaXRlIHRoZSBzcGVjaWZpY2F0aW9uXG4gICAgLy8gaHR0cHM6Ly9naXRodWIuY29tL2FuZ3VsYXIvYW5ndWxhci9pc3N1ZXMvNjE0MlxuICAgIGxpbms6ICdsaW5rJyxcbiAgICBMaW5rOiAnTGluaycsXG5cbiAgICB4X3ZjbG91ZF9hdXRob3JpemF0aW9uOiAneC12Y2xvdWQtYXV0aG9yaXphdGlvbidcbn0pO1xuIl19

package/esm2020/client/client/index.mjs

@@ -0,0 +1,8 @@
+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';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy92Y2Qvc2RrL3NyYy9jbGllbnQvY2xpZW50L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYywrQkFBK0IsQ0FBQztBQUM5QyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsc0NBQXNDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2FwaS5yZXN1bHQuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3ZjZC5odHRwLmNsaWVudCc7XG5leHBvcnQgKiBmcm9tICcuL3ZjZC5hcGkuY2xpZW50JztcbmV4cG9ydCAqIGZyb20gJy4vdmNkLnRyYW5zZmVyLmNsaWVudCc7XG5leHBvcnQgKiBmcm9tICcuL3JlcXVlc3QuaGVhZGVycy5pbnRlcmNlcHRvcic7XG5leHBvcnQgKiBmcm9tICcuL2xvZ2dpbmcuaW50ZXJjZXB0b3InO1xuZXhwb3J0ICogZnJvbSAnLi9yZXNwb25zZS5ub3JtYWxpemF0aW9uLmludGVyY2VwdG9yJztcbiJdfQ==

package/esm2020/client/client/logging.interceptor.mjs

@@ -0,0 +1,44 @@
+import { Injectable, Optional } from '@angular/core';
+import { HttpResponse } from '@angular/common/http';
+import { finalize, tap } from 'rxjs/operators';
+import { ApiResult } from './api.result.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./api.result.service";
+// tslint:disable:variable-name
+export class LoggingInterceptor {
+    set enabled(enabled) {
+        this._enabled = enabled;
+        if (this._enabled && this._outputToConsole) {
+            console.warn('API logging enabled but no provider found for ApiResultService.  Results will be output to the console.');
+        }
+    }
+    constructor(apiResultService) {
+        this.apiResultService = apiResultService;
+        this._enabled = false;
+        this._outputToConsole = !this.apiResultService;
+    }
+    intercept(req, next) {
+        if (!this._enabled) {
+            return next.handle(req);
+        }
+        const started = new Date();
+        let succeeded;
+        return next.handle(req)
+            .pipe(tap(event => succeeded = event instanceof HttpResponse ? true : false, error => succeeded = false), finalize(() => {
+            if (this._outputToConsole) {
+                console.log(`${req.method} ${req.urlWithParams} completed in ${Date.now() - started.getTime()} ms.  Success: ${succeeded}`);
+            }
+            else {
+                this.apiResultService.add(new ApiResult(`${req.method} ${req.urlWithParams}`, succeeded, started, new Date()));
+            }
+        }));
+    }
+}
+LoggingInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: LoggingInterceptor, deps: [{ token: i1.ApiResultService, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+LoggingInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: LoggingInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: LoggingInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.ApiResultService, decorators: [{
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/client/client/request.headers.interceptor.mjs

@@ -0,0 +1,91 @@
+import { Injectable } from '@angular/core';
+import { HttpResponse } from '@angular/common/http';
+import { map } from 'rxjs/operators';
+import { parseHeaderHateoasLinks } from '.';
+import { HTTP_HEADERS } from './constants';
+import * as i0 from "@angular/core";
+// tslint:disable:variable-name
+export class RequestHeadersInterceptor {
+    constructor() {
+        this._enabled = true;
+        this._version = '';
+        this._authenticationHeader = HTTP_HEADERS.Authorization;
+    }
+    set enabled(_enabled) {
+        this._enabled = _enabled;
+    }
+    set actAs(_actAs) {
+        this._actAs = _actAs;
+    }
+    get version() {
+        return this._version;
+    }
+    set version(_version) {
+        this._version = _version;
+    }
+    set authentication(_authentication) {
+        this._authentication = _authentication;
+        this._authenticationHeader = (this._authentication && this._authentication.length > 32) ?
+            HTTP_HEADERS.Authorization : HTTP_HEADERS.x_vcloud_authorization;
+    }
+    intercept(req, next) {
+        let headers = req.headers;
+        if (!headers.has('Accept')) {
+            headers = this.setAcceptHeader(headers);
+        }
+        if (!headers.has('Content-Type')) {
+            headers = this.setContentTypeHeader(headers, req.url);
+        }
+        if (this._authentication && !headers.has(HTTP_HEADERS.Authorization)) {
+            headers = headers.set(this._authenticationHeader, this._authentication);
+        }
+        /**
+         * Covers the case where the User set the ActAs token himself
+         */
+        if (!headers.has('X-VMWARE-VCLOUD-TENANT-CONTEXT') && this._actAs) {
+            headers = headers.set('X-VMWARE-VCLOUD-TENANT-CONTEXT', this._actAs);
+        }
+        const customReq = req.clone({
+            headers
+        });
+        return next.handle(customReq).pipe(map((res) => {
+            if (res instanceof HttpResponse) {
+                if (!res.body || !res.headers) {
+                    return res;
+                }
+                if (res.headers.has(HTTP_HEADERS.link)) {
+                    res.body.link = parseHeaderHateoasLinks(res.headers.get(HTTP_HEADERS.link));
+                }
+                if (res.headers.has(HTTP_HEADERS.Link)) {
+                    res.body.link = parseHeaderHateoasLinks(res.headers.get(HTTP_HEADERS.Link));
+                }
+                if (res.headers.has(HTTP_HEADERS.etag)) {
+                    res.body.etag = res.headers.get(HTTP_HEADERS.etag);
+                }
+            }
+            return res;
+        }));
+    }
+    setAcceptHeader(headers) {
+        const value = headers.get('_multisite');
+        headers = headers.delete('_multisite');
+        return headers.set('Accept', [
+            `application/*+json;version=${this._version}${value ? `;multisite=${value}` : ''}`,
+            `application/json;version=${this._version}${value ? `;multisite=${value}` : ''}`
+        ]);
+    }
+    setContentTypeHeader(headers, url) {
+        if (url.indexOf('cloudapi') > -1) {
+            return headers.set('Content-Type', 'application/json');
+        }
+        else {
+            return headers.set('Content-Type', 'application/*+json');
+        }
+    }
+}
+RequestHeadersInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: RequestHeadersInterceptor, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+RequestHeadersInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: RequestHeadersInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: RequestHeadersInterceptor, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"request.headers.interceptor.js","sourceRoot":"","sources":["../../../../../../projects/vcd/sdk/src/client/client/request.headers.interceptor.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { HttpHandler, HttpInterceptor, HttpRequest, HttpEvent, HttpHeaders, HttpResponse } from '@angular/common/http';\nimport { Observable } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport { parseHeaderHateoasLinks } from '.';\nimport { HTTP_HEADERS } from './constants';\n\n// tslint:disable:variable-name\n@Injectable()\nexport class RequestHeadersInterceptor implements HttpInterceptor {\n    private _enabled = true;\n    set enabled(_enabled: boolean) {\n        this._enabled = _enabled;\n    }\n\n    private _actAs: string;\n    set actAs(_actAs: string) {\n        this._actAs = _actAs;\n    }\n\n    private _version = '';\n    get version(): string {\n        return this._version;\n    }\n    set version(_version: string) {\n        this._version = _version;\n    }\n\n    private _authenticationHeader: string = HTTP_HEADERS.Authorization;\n    private _authentication: string;\n    set authentication(_authentication: string) {\n        this._authentication = _authentication;\n        this._authenticationHeader = (this._authentication && this._authentication.length > 32) ?\n            HTTP_HEADERS.Authorization : HTTP_HEADERS.x_vcloud_authorization;\n    }\n\n    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {\n        let headers = req.headers;\n\n        if (!headers.has('Accept')) {\n            headers = this.setAcceptHeader(headers);\n        }\n\n        if (!headers.has('Content-Type')) {\n            headers = this.setContentTypeHeader(headers, req.url);\n        }\n\n        if (this._authentication && !headers.has(HTTP_HEADERS.Authorization)) {\n            headers = headers.set(this._authenticationHeader, this._authentication);\n        }\n\n        /**\n         * Covers the case where the User set the ActAs token himself\n         */\n        if (!headers.has('X-VMWARE-VCLOUD-TENANT-CONTEXT') && this._actAs) {\n            headers = headers.set('X-VMWARE-VCLOUD-TENANT-CONTEXT', this._actAs);\n        }\n\n        const customReq: HttpRequest<any> = req.clone({\n            headers\n        });\n\n        return next.handle(customReq).pipe(\n            map((res: HttpEvent<any>) => {\n                if (res instanceof HttpResponse) {\n                    if (!res.body || !res.headers) {\n                        return res;\n                    }\n\n                    if (res.headers.has(HTTP_HEADERS.link)) {\n                        res.body.link = parseHeaderHateoasLinks(res.headers.get(HTTP_HEADERS.link));\n                    }\n\n                    if (res.headers.has(HTTP_HEADERS.Link)) {\n                        res.body.link = parseHeaderHateoasLinks(res.headers.get(HTTP_HEADERS.Link));\n                    }\n\n                    if (res.headers.has(HTTP_HEADERS.etag)) {\n                        res.body.etag = res.headers.get(HTTP_HEADERS.etag);\n                    }\n                }\n                return res;\n            })\n        );\n    }\n\n    private setAcceptHeader(headers: HttpHeaders): HttpHeaders {\n        const value = headers.get('_multisite');\n        headers = headers.delete('_multisite');\n\n        return headers.set(\n            'Accept', [\n                `application/*+json;version=${this._version}${value ? `;multisite=${value}` : ''}`,\n                `application/json;version=${this._version}${value ? `;multisite=${value}` : ''}`\n            ]\n        );\n    }\n\n    private setContentTypeHeader(headers: HttpHeaders, url: string): HttpHeaders {\n        if (url.indexOf('cloudapi') > -1) {\n            return headers.set('Content-Type', 'application/json');\n        } else {\n            return headers.set('Content-Type', 'application/*+json');\n        }\n    }\n}\n"]}

package/esm2020/client/client/response.normalization.interceptor.mjs

@@ -0,0 +1,59 @@
+import { Injectable } from '@angular/core';
+import { HttpResponse } from '@angular/common/http';
+import { map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+// tslint:disable:jsdoc-format
+/**
+ * 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 class ResponseNormalizationInterceptor {
+    intercept(req, next) {
+        return next.handle(req).pipe(map(response => {
+            // While this condition seems awfully specific, the alternative option of examining the 'Content-Type'
+            // response header for 'version=30.0' proved to be an unreliable condition in at least one case;
+            // returning the same JSON payload as API versions >= 31.0.
+            if (response instanceof HttpResponse && response.body && response.body.value && response.body.declaredType && response.body.scope) {
+                const body = response.body.value;
+                if (response.body.declaredType === ResponseNormalizationInterceptor.QUERY_RESULT_TYPE) {
+                    body.record = body.record.map(record => record.value);
+                }
+                return response.clone({ body });
+            }
+            return response;
+        }));
+    }
+}
+ResponseNormalizationInterceptor.QUERY_RESULT_TYPE = 'com.vmware.vcloud.api.rest.schema_v1_5.QueryResultRecordsType';
+ResponseNormalizationInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: ResponseNormalizationInterceptor, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ResponseNormalizationInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: ResponseNormalizationInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: ResponseNormalizationInterceptor, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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