@vcd/sdk 15.0.8 → 17.0.0

package/esm2022/client/client/vcd.api.client.mjs

@@ -0,0 +1,603 @@
+import { Injectable, Optional } from '@angular/core';
+import { HttpHeaders } from '@angular/common/http';
+import { BehaviorSubject, merge, of, ReplaySubject, throwError } from 'rxjs';
+import { catchError, concatMap, filter, map, share, skipWhile, switchMap, tap, withLatestFrom } from 'rxjs/operators';
+import { TaskType } from '@vcd/bindings/vcloud/api/rest/schema_v1_5';
+import { API_ROOT_URL, AuthTokenHolderService, SESSION_ORG_ID, SESSION_SCOPE } from '../../common/container-hooks';
+import { VcdTransferClient } from './vcd.transfer.client';
+import { HTTP_HEADERS } from './constants';
+import { ClientError, ClientErrorType } from "./types";
+import * as i0 from "@angular/core";
+import * as i1 from "./vcd.http.client";
+import * as i2 from "../../core/plugin.module";
+export const TRANSFER_LINK_REL = 'upload:default';
+export const HATEOAS_HEADER = 'Link';
+// tslint:disable:variable-name
+/**
+ * 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 function parseHeaderHateoasLinks(header) {
+    const results = [];
+    if (!header) {
+        return results;
+    }
+    const headerFieldMappings = {
+        href: 'href',
+        model: 'type',
+        title: 'id',
+        rel: 'rel'
+    };
+    let tokenIndex = -1;
+    function peek(token) {
+        return header.indexOf(token, tokenIndex + 1);
+    }
+    function next(token) {
+        const nextIndex = peek(token);
+        if (nextIndex === -1) {
+            throw new Error(JSON.stringify({ header, token, tokenIndex }));
+        }
+        tokenIndex = nextIndex;
+        return tokenIndex;
+    }
+    while (peek('<') > -1) {
+        try {
+            const hrefStart = next('<');
+            const hrefEnd = next('>');
+            const href = header.substring(hrefStart + 1, hrefEnd);
+            const result = { href, type: null, id: null, rel: null, vCloudExtension: [] };
+            let comma = peek(',');
+            let semicolon = peek(';');
+            while ((semicolon > -1 && comma > -1 && semicolon < comma) || (semicolon > -1 && comma === -1)) {
+                const nameStart = next(';');
+                const nameEnd = next('=');
+                const name = header.substring(nameStart + 1, nameEnd).trim().toLowerCase();
+                const valueStart = next('"');
+                const valueEnd = next('"');
+                const value = header.substring(valueStart + 1, valueEnd);
+                const mappedName = headerFieldMappings[name];
+                if (mappedName) {
+                    // @ts-ignore
+                    result[mappedName] = decodeURIComponent(value);
+                }
+                comma = peek(',');
+                semicolon = peek(';');
+            }
+            results.push(result);
+        }
+        catch (error) { // We will try the next one...
+            console.log(error);
+        }
+    }
+    return results;
+}
+export var LinkRelType;
+(function (LinkRelType) {
+    LinkRelType["add"] = "add";
+    LinkRelType["remove"] = "remove";
+    LinkRelType["edit"] = "edit";
+})(LinkRelType || (LinkRelType = {}));
+/**
+ * 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 class VcdApiClient {
+    set baseUrl(_baseUrl) {
+        this._baseUrl = _baseUrl;
+    }
+    get version() {
+        return this.http.requestHeadersInterceptor.version;
+    }
+    constructor(http, injector, config) {
+        this.http = http;
+        this.injector = injector;
+        this.config = config;
+        /**
+         * @deprecated Use {@link VcdApiClient#_cloudApiSession}
+         */
+        this._session = new BehaviorSubject(null);
+        this._sessionObservable = this._session.asObservable()
+            .pipe(skipWhile(session => !session));
+        /**
+         * CloudApi Session
+         */
+        this._cloudApiSession = new BehaviorSubject(null);
+        this._cloudApiSessionObservable = this._cloudApiSession.asObservable()
+            .pipe(skipWhile(session => !session));
+        this._cloudApiSessionLinks = new BehaviorSubject([]);
+        /**
+         * 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.
+         */
+        this._isCloudApiLogin = false;
+        this._baseUrl = this.injector.get(API_ROOT_URL);
+        let negotiatedVersion;
+        if (this.config?.apiVersion) {
+            negotiatedVersion = of(this.config.apiVersion).pipe(map((version) => {
+                this.setVersion(version);
+                return version;
+            }));
+        }
+        else {
+            negotiatedVersion = this.http.get(`${this._baseUrl}/api/versions`).pipe(map(versions => this.negotiateVersion(versions)), tap(version => this.setVersion(version)));
+        }
+        this._negotiateVersion = negotiatedVersion.pipe(share({ connector: () => new ReplaySubject(1), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }));
+        const tokenHolder = this.injector.get(AuthTokenHolderService, { token: '' });
+        const token = tokenHolder.jwt ? `Bearer ${tokenHolder.jwt}` : tokenHolder.token;
+        this._getSession = this.setAuthentication(token)
+            .pipe(share({ connector: () => new ReplaySubject(1), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }));
+        this._getCloudApiSession = this.setCloudApiAuthentication(token)
+            .pipe(share({ connector: () => new ReplaySubject(1), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }));
+        // This is not an explicit cloud api login
+        this._isCloudApiLogin = false;
+    }
+    negotiateVersion(serverVersions) {
+        const supportedVersions = serverVersions.versionInfo.map(versionInfo => versionInfo.version);
+        // Default API Version used is the Latest API Version in VMware Cloud Director
+        return supportedVersions[supportedVersions.length - 1];
+    }
+    /**
+     * 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.
+     */
+    validateRequestContext() {
+        return (this.version ? of(this.version) : this._negotiateVersion)
+            .pipe(
+        // In case of a cloud api login we are not interested in the /api/session session
+        concatMap(() => this._isCloudApiLogin ? of(null) : this._getSession), concatMap(() => this._getCloudApiSession
+            // In case of cloud api failure we do not want to prevent further execution
+            // for backward compatibility considerations since this may be a case
+            // when cloud api is not supported at all for the specified version
+            .pipe(catchError((e) => of(true)))), map(() => true));
+    }
+    /**
+     *
+     * For use cases wich solely depends on cloudapi without any backward compatibility
+     * there should be no dependence on the old /api endpoint at all
+     */
+    validateRequestContextCloudApiOnly() {
+        return (this.version ? of(this.version) : this._negotiateVersion).pipe(concatMap(() => this._getCloudApiSession));
+    }
+    setVersion(_version) {
+        this.http.requestHeadersInterceptor.version = _version;
+        return this;
+    }
+    /**
+     * 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 = null) {
+        this.http.requestHeadersInterceptor.actAs = !actAs ? null : actAs.id;
+        this.http.requestHeadersInterceptor.actAsOrgName = !actAs ? null : actAs.name;
+        return this;
+    }
+    /**
+     * @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) {
+        if (this._isCloudApiLogin) {
+            return throwError('Only cloud api auth is allowed since it was already used');
+        }
+        this.http.requestHeadersInterceptor.authentication = authentication;
+        return this.http.get(`${this._baseUrl}/api/session`).pipe(tap(session => {
+            // automatically set actAs for provider in tenant scope
+            if (session.org === 'System' && this.injector.get(SESSION_SCOPE) === 'tenant') {
+                // Automatic actAs only works in versions >=9.5
+                try {
+                    this.actAs({ id: this.injector.get(SESSION_ORG_ID) });
+                }
+                catch (e) {
+                    console.warn('No SESSION_ORG_ID set in container. Automatic actAs is disabled.');
+                }
+            }
+        }), tap(session => this._session.next(session)));
+    }
+    /**
+     * 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) {
+        this.onBeforeCloudApiAuthentication();
+        return of(true)
+            .pipe(
+        // Set the authentication as part of the observable in order to ensure the caller has subscribed to the observable
+        tap(() => this.http.requestHeadersInterceptor.authentication = authentication), switchMap(() => this.http.get(`${this._baseUrl}/cloudapi/1.0.0/sessions/current`, { observe: 'response' })))
+            .pipe(this.onCloudApiAuthentication());
+    }
+    enableLogging() {
+        this.http.loggingInterceptor.enabled = true;
+        return this;
+    }
+    /**
+     * @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, tenant, password) {
+        if (this._isCloudApiLogin) {
+            return throwError('Only cloud api auth is allowed since it was already used');
+        }
+        const authString = btoa(`${username}@${tenant}:${password}`);
+        return this.http.post(`${this._baseUrl}/api/sessions`, null, {
+            observe: 'response',
+            headers: new HttpHeaders({ Authorization: `Basic ${authString}` })
+        })
+            .pipe(tap((response) => 
+        // tslint:disable-next-line:max-line-length
+        this.http.requestHeadersInterceptor.authentication = `${response.headers.get('x-vmware-vcloud-token-type')} ${response.headers.get('x-vmware-vcloud-access-token')}`), map(response => response.body), tap(session => this._session.next(session)));
+    }
+    /**
+     * 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, tenant, password) {
+        this.onBeforeCloudApiAuthentication();
+        const authString = btoa(`${username}@${tenant}:${password}`);
+        let url = `${this._baseUrl}/cloudapi/1.0.0/sessions`;
+        if (tenant.toLowerCase() === 'system') {
+            url += '/provider';
+        }
+        return this.http.post(url, null, {
+            observe: 'response',
+            headers: new HttpHeaders({ [HTTP_HEADERS.Authorization]: `Basic ${authString}` })
+        }).pipe(tap((response) => {
+            // tslint:disable-next-line:max-line-length
+            const token = `${response.headers.get('x-vmware-vcloud-token-type')} ${response.headers.get('x-vmware-vcloud-access-token')}`;
+            this.http.requestHeadersInterceptor.authentication = token;
+        }), this.onCloudApiAuthentication());
+    }
+    /**
+     * 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.
+     */
+    onBeforeCloudApiAuthentication() {
+        // In case of an explicit cloud api auth request:
+        // Set the flag _isCloudApiLogin in order to know that explicit cloud api authentication is done
+        // This will help us skip code related to the old api, i.e. we should not allow explicit mix of both the api-s
+        this._isCloudApiLogin = true;
+        // In case of an explicit cloud api auth request:
+        // There is no need of _getCloudApiSession observable which is needed in the automatic login during the constructor initialization.
+        // The explicit cloud api auth request will retrieve the session.
+        this._getCloudApiSession = of(null);
+    }
+    /**
+     * Handle authentication.
+     * This includes getting HATEOAS links, setting the session, handling errors etc.
+     */
+    onCloudApiAuthentication() {
+        return (source) => source.pipe(tap((resp) => {
+            // Get HATEOAS links
+            try {
+                this.setCloudApiSessionLinks(parseHeaderHateoasLinks(resp.headers.get(HATEOAS_HEADER)));
+            }
+            catch (e) {
+                console.log('Error when parsing session HATEOAS links:', e);
+            }
+        }), map(resp => resp.body), tap((session) => {
+            // Clear previous actAs
+            this.actAs(null);
+            // automatically set actAs for provider in tenant scope
+            if (session.org && session.org.name === 'System' && this.injector.get(SESSION_SCOPE) === 'tenant') {
+                // Automatic actAs only works in versions >=9.5
+                try {
+                    this.actAs({ id: this.injector.get(SESSION_ORG_ID) });
+                }
+                catch (e) {
+                    console.warn('No SESSION_ORG_ID set in container. Automatic actAs is disabled.');
+                }
+            }
+        }), tap((session) => this._cloudApiSession.next(session)), catchError((e) => {
+            this.onCloudApiAuthenticationError();
+            return throwError(e);
+        }));
+    }
+    onCloudApiAuthenticationError() {
+        // Clear the authentication so that any subsequent backend calls are not authenticated
+        this.http.requestHeadersInterceptor.authentication = '';
+        // _getCloudApiSession is in the center of any backend call, nullify it in order not to prevent those calls
+        // since it is easier to troubleshoot failing backend rather than no call
+        this._getCloudApiSession = of(null);
+        // Clear the links
+        this._cloudApiSessionLinks.next([]);
+        // Clear the session
+        this._cloudApiSession.next(null);
+    }
+    setCloudApiSessionLinks(links) {
+        this._cloudApiAccessibleLocations = null;
+        this._cloudApiSessionLinks.next(links || []);
+    }
+    get(endpoint, options) {
+        return this.validateRequestContext().pipe(concatMap(() => this.http.get(this.buildEndpointUrl(endpoint), { ...options })));
+    }
+    list(endpoint, queryBuilder, multisite, options) {
+        let url = this.buildEndpointUrl(endpoint);
+        if (queryBuilder) {
+            url = `${url}${queryBuilder.getCloudAPI()}`;
+        }
+        if (multisite) {
+            if (!options) {
+                return this.http.get(url, { headers: new HttpHeaders({ _multisite: this.parseMultisiteValue(multisite) }) });
+            }
+            else if (options?.headers) {
+                options.headers.append("_multisite", this.parseMultisiteValue(multisite));
+                return this.http.get(url, { ...options });
+            }
+        }
+        return this.validateRequestContext().pipe(concatMap(() => this.http.get(url, { ...options })));
+    }
+    createSync(endpoint, item, options) {
+        return this.validateRequestContext().pipe(concatMap(() => this.http.post(this.buildEndpointUrl(endpoint), item, { ...options })));
+    }
+    createAsync(endpoint, item, options) {
+        return this.validateRequestContext().pipe(concatMap(() => this.http.post(this.buildEndpointUrl(endpoint), item, { ...options, observe: 'response' })), concatMap(response => this.mapResponseToTask(response, 'POST')));
+    }
+    getTransferLink(endpoint, item, transferRel = TRANSFER_LINK_REL) {
+        return this.http
+            .post(this.buildEndpointUrl(endpoint), item, { observe: 'response' })
+            .pipe(map((res) => {
+            const headerLinks = res.headers.has(HATEOAS_HEADER)
+                ? parseHeaderHateoasLinks(res.headers.get(HATEOAS_HEADER))
+                : [];
+            const links = res.body ? (res.body.link || []) : [];
+            const link = [...headerLinks, ...links]
+                .find((l) => l.rel === transferRel);
+            if (!link) {
+                throw new ClientError(`Response from ${endpoint} did not contain a transfer link`, ClientErrorType.HateoasLinkMissing);
+            }
+            return link.href;
+        }));
+    }
+    startTransfer(endpoint, item, transferRel = TRANSFER_LINK_REL) {
+        return this.getTransferLink(endpoint, item, transferRel)
+            .pipe(map((transferUrl) => new VcdTransferClient(this.http, transferUrl)));
+    }
+    updateSync(endpoint, item, options) {
+        return this.validateRequestContext().pipe(concatMap(() => this.http.put(this.buildEndpointUrl(endpoint), item, { ...options })));
+    }
+    updateAsync(endpoint, item, options) {
+        return this.validateRequestContext().pipe(concatMap(() => this.http.put(this.buildEndpointUrl(endpoint), item, { ...options, observe: 'response' })), concatMap(response => this.mapResponseToTask(response, 'PUT')));
+    }
+    deleteSync(endpoint, options) {
+        return this.validateRequestContext().pipe(concatMap(() => this.http.delete(this.buildEndpointUrl(endpoint), { ...options })));
+    }
+    deleteAsync(endpoint, options) {
+        return this.validateRequestContext().pipe(concatMap(() => this.http.delete(this.buildEndpointUrl(endpoint), { ...options, observe: 'response' })), concatMap(response => this.mapResponseToTask(response, 'DELETE')));
+    }
+    mapResponseToTask(response, httpVerb) {
+        if (response.headers.has('Location') && response.status === 202) {
+            return this.http.get(response.headers.get('Location'));
+        }
+        else if (response.body && response.body.type.startsWith('application/vnd.vmware.vcloud.task+')) {
+            const task = Object.assign(new TaskType(), response.body);
+            return of(task);
+        }
+        return throwError(() => new ClientError(`An asynchronous request was made to [${httpVerb} ${response.url}], but no task was returned.  The operation may still have been successful.`, ClientErrorType.TaskLinkMissing));
+    }
+    getEntity(entityRefOrUrn) {
+        const entityResolver = typeof entityRefOrUrn === 'string' ?
+            this.http.get(`${this._baseUrl}/api/entity/${entityRefOrUrn}`) :
+            this.http.get(`${this._baseUrl}/api/entity/urn:vcloud:${entityRefOrUrn.type}:${entityRefOrUrn.id}`);
+        return this.validateRequestContext().pipe(concatMap(() => entityResolver), concatMap(entity => this.http.get(`${entity.link[0].href}`)));
+    }
+    updateTask(task, options) {
+        return this.validateRequestContext().pipe(concatMap(() => this.http.get(task.href, { ...options })));
+    }
+    isTaskComplete(task) {
+        return ['success', 'error', 'canceled', 'aborted'].indexOf(task.status) > -1;
+    }
+    removeItem(item, options) {
+        const link = this.findLink(item, 'remove', null);
+        if (!link) {
+            return throwError(() => new ClientError(`No 'remove' link for specified resource.`, ClientErrorType.HateoasLinkMissing));
+        }
+        return this.validateRequestContext().pipe(concatMap(() => this.http.delete(link.href, { ...options })));
+    }
+    query(builder, multisite, options) {
+        return this.getQueryPage(`${this._baseUrl}/api/query${builder.get()}`, multisite, options);
+    }
+    firstPage(result, multisite, options) {
+        const link = this.findLink(result, 'firstPage', result.type);
+        if (!link) {
+            return throwError(() => new ClientError(`No 'firstPage' link for specified query.`, ClientErrorType.HateoasLinkMissing));
+        }
+        return this.getQueryPage(link.href, multisite, options);
+    }
+    hasFirstPage(result) {
+        return !!this.findLink(result, 'firstPage', result.type);
+    }
+    previousPage(result, multisite, options) {
+        const link = this.findLink(result, 'previousPage', result.type);
+        if (!link) {
+            return throwError(() => new ClientError(`No 'previousPage' link for specified query.`, ClientErrorType.HateoasLinkMissing));
+        }
+        return this.getQueryPage(link.href, multisite, options);
+    }
+    hasPreviousPage(result) {
+        return !!this.findLink(result, 'previousPage', result.type);
+    }
+    nextPage(result, multisite, options) {
+        const link = this.findLink(result, 'nextPage', result.type);
+        if (!link) {
+            return throwError(() => new ClientError(`No 'nextPage' link for specified query.`, ClientErrorType.HateoasLinkMissing));
+        }
+        return this.getQueryPage(link.href, multisite, options);
+    }
+    hasNextPage(result) {
+        return !!this.findLink(result, 'nextPage', result.type);
+    }
+    lastPage(result, multisite, options) {
+        const link = this.findLink(result, 'lastPage', result.type);
+        if (!link) {
+            return throwError(() => new ClientError(`No 'lastPage' link for specified query.`, ClientErrorType.HateoasLinkMissing));
+        }
+        return this.getQueryPage(link.href, multisite, options);
+    }
+    hasLastPage(result) {
+        return !!this.findLink(result, 'lastPage', result.type);
+    }
+    getQueryPage(href, multisite, options) {
+        if (multisite) {
+            if (!options) {
+                return this.http.get(href, { headers: new HttpHeaders({ _multisite: this.parseMultisiteValue(multisite) }) });
+            }
+            else if (options?.headers) {
+                options.headers.append("_multisite", this.parseMultisiteValue(multisite));
+                return this.http.get(href, { ...options });
+            }
+        }
+        return this.validateRequestContext().pipe(concatMap(() => this.http.get(href, { ...options })));
+    }
+    /**
+     * 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, linkRelType, entityRefType) {
+        return !!this.findLink(item, linkRelType, entityRefType);
+    }
+    findLink(item, rel, type) {
+        if (!item || !item.link) {
+            return undefined;
+        }
+        return item.link.find((link) => {
+            if (type) {
+                return link.rel.includes(rel) && link.type === type;
+            }
+            return link.rel.includes(rel);
+        });
+    }
+    parseMultisiteValue(multisite) {
+        return typeof multisite === 'boolean' ? (multisite ? 'global' : 'local') : multisite.map(site => site.locationId).join(',');
+    }
+    /**
+     * @deprecated Use cloudApiSession
+     */
+    get session() {
+        return this.validateRequestContext().pipe(concatMap(() => this._sessionObservable));
+    }
+    /**
+     * Get Session observable
+     */
+    get cloudApiSession() {
+        return this.validateRequestContextCloudApiOnly().pipe(concatMap(() => this._cloudApiSessionObservable));
+    }
+    get username() {
+        return merge(this.cloudApiSession.pipe(filter(() => this._isCloudApiLogin), map(session => session && session.user && session.user.name)), this.session.pipe(filter(() => !this._isCloudApiLogin), map(session => session && session.user)));
+    }
+    get organization() {
+        return merge(this.cloudApiSession.pipe(filter(() => this._isCloudApiLogin), map(session => session && session.org && session.org.name)), this.session.pipe(filter(() => !this._isCloudApiLogin), map(session => session && session.org)));
+    }
+    /**
+     * @deprecated Use cloudApiLocation
+     */
+    get location() {
+        return this.session.pipe(map(session => session.authorizedLocations.location.find(location => location.locationId === session.locationId)));
+    }
+    /**
+     * Gets the location corresponding to the current session
+     */
+    get cloudApiLocation() {
+        return this.cloudApiSession.pipe(switchMap(() => {
+            if (!this._cloudApiAccessibleLocations) {
+                // Ensure caching for getting AccessibleLocations
+                this._cloudApiAccessibleLocations = this._cloudApiSessionLinks
+                    .pipe(
+                // Get the AccessibleLocations link
+                map((links) => this.findLink({ link: links }, 'down', 'AccessibleLocations')), 
+                // Fetch AccessibleLocations from the backend
+                switchMap((link) => link ? this.http.get(link.href) : of(null)), 
+                // Get the array with all locations (what if there are many pages)
+                map((accessibleLocations) => accessibleLocations && accessibleLocations.values))
+                    .pipe(share({ connector: () => new ReplaySubject(1), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }));
+            }
+            return this._cloudApiAccessibleLocations;
+        }), 
+        // Need to have the session in order to get its location
+        withLatestFrom(this.cloudApiSession), 
+        // Find the location that corresponds to this session
+        map(([accessibleLocations, session]) => {
+            if (!accessibleLocations || !session) {
+                return null;
+            }
+            const sessionLocation = session.location;
+            if (!sessionLocation) {
+                return null;
+            }
+            return accessibleLocations.find(location => location.locationId === sessionLocation);
+        }));
+    }
+    getLocation(session) {
+        return session.authorizedLocations.location.find(location => location.locationId === session.locationId);
+    }
+    /**
+     * 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.
+     */
+    buildEndpointUrl(endpoint) {
+        return endpoint.indexOf('://') > -1 ? endpoint : `${this._baseUrl}/${endpoint}`;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: VcdApiClient, deps: [{ token: i1.VcdHttpClient }, { token: i0.Injector }, { token: i2.VcdSdkConfig, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: VcdApiClient }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: VcdApiClient, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.VcdHttpClient }, { type: i0.Injector }, { type: i2.VcdSdkConfig, decorators: [{
+                    type: Optional
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vcd.api.client.js","sourceRoot":"","sources":["../../../../../../projects/vcd/sdk/src/client/client/vcd.api.client.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable, Injector, Optional} from '@angular/core';\nimport {HttpHeaders, HttpResponse} from '@angular/common/http';\nimport {BehaviorSubject, merge, Observable, of, ReplaySubject, throwError} from 'rxjs';\nimport {catchError, concatMap, filter, map, share, skipWhile, switchMap, tap, withLatestFrom} from 'rxjs/operators';\nimport {\n  AuthorizedLocationType,\n  EntityReferenceType,\n  EntityType,\n  LinkType,\n  ResourceType,\n  SessionType,\n  TaskType\n} from '@vcd/bindings/vcloud/api/rest/schema_v1_5';\nimport {SupportedVersionsType} from '@vcd/bindings/vcloud/api/rest/schema/versioning';\nimport {AccessibleLocation, AccessibleLocations, Session} from '../openapi';\nimport {Query} from '../query/index';\nimport {API_ROOT_URL, AuthTokenHolderService, SESSION_ORG_ID, SESSION_SCOPE} from '../../common/container-hooks';\nimport {VcdHttpClient} from './vcd.http.client';\nimport {VcdTransferClient} from './vcd.transfer.client';\nimport {HTTP_HEADERS} from './constants';\nimport {VcdSdkConfig} from \"../../core/plugin.module\";\nimport {ClientError, ClientErrorType} from \"./types\";\n\nexport const TRANSFER_LINK_REL = 'upload:default';\nexport type Navigable = ResourceType | { link?: LinkType[] };\n\nexport const HATEOAS_HEADER = 'Link';\n\n// tslint:disable:variable-name\n\n/**\n * Parse out Link headers using a very lazily implemented pull parser\n * @param header '<url1>;name1=\"value1\",name2=\"value2\",<url2>;name3=\"value3,value4\"'\n * @returns parsed link headers\n */\nexport function parseHeaderHateoasLinks(header: string): LinkType[] {\n    const results: LinkType[] = [];\n\n    if (!header) {\n        return results;\n    }\n\n    const headerFieldMappings: {[key: string]: keyof LinkType} = {\n        href: 'href',\n        model: 'type',\n        title: 'id',\n        rel: 'rel'\n    };\n    let tokenIndex = -1;\n\n    function peek(token: string) {\n        return header.indexOf(token, tokenIndex + 1);\n    }\n\n    function next(token: string) {\n        const nextIndex = peek(token);\n        if (nextIndex === -1) {\n            throw new Error(JSON.stringify({header, token, tokenIndex}));\n        }\n        tokenIndex = nextIndex;\n        return tokenIndex;\n    }\n\n    while (peek('<') > -1) {\n        try {\n            const hrefStart = next('<');\n            const hrefEnd = next('>');\n            const href = header.substring(hrefStart + 1, hrefEnd);\n            const result: LinkType = {href, type: null, id: null, rel: null, vCloudExtension: []};\n            let comma = peek(',');\n            let semicolon = peek(';');\n            while ((semicolon > -1 && comma > -1 && semicolon < comma) || (semicolon > -1 && comma === -1)) {\n                const nameStart = next(';');\n                const nameEnd = next('=');\n                const name = header.substring(nameStart + 1, nameEnd).trim().toLowerCase();\n                const valueStart = next('\"');\n                const valueEnd = next('\"');\n                const value = header.substring(valueStart + 1, valueEnd);\n                const mappedName = headerFieldMappings[name];\n                if (mappedName) {\n                    // @ts-ignore\n                    result[mappedName] = decodeURIComponent(value) as any;\n                }\n                comma = peek(',');\n                semicolon = peek(';');\n            }\n            results.push(result);\n        } catch (error) {  // We will try the next one...\n            console.log(error);\n        }\n    }\n\n    return results;\n}\n\nexport enum LinkRelType {\n    add = 'add',\n    remove = 'remove',\n    edit = 'edit',\n}\n\n/**\n * A basic client for interacting with the VMware Cloud Director APIs.\n *\n * A VMware Cloud Director plugin can get a reference to this client by using angular injection.\n * ```\n *     constructor(private vcdApi: VcdApiClient) {}\n * ```\n *\n * VcdApiClient reuses the authentication from the VCD platform so in general there is\n * no need of an explicit authentication/login.\n *\n * When dealing with the session management there are two APIs:\n * 1. Deprecated legacy API that is using the `api/session` endpoint and the corresponding models\n * 2. Newly added API that is using the `cloudapi` endpoint and the corresponding models\n *\n * Note that if a plugin performs an explicit cloud api authentication call through\n * {@link VcdApiClient#setCloudApiAuthentication} or {@link VcdApiClient#cloudApiLogin}\n * from that moment on the VcdApiClient uses only cloud api session management.\n * This means calls to {@link VcdApiClient#setAuthentication} or {@link VcdApiClient#login} have no effect.\n */\n@Injectable()\nexport class VcdApiClient {\n    set baseUrl(_baseUrl: string) {\n        this._baseUrl = _baseUrl;\n    }\n\n    get version(): string {\n        return this.http.requestHeadersInterceptor.version;\n    }\n\n    private _negotiateVersion: Observable<string>;\n    private _baseUrl: string;\n\n    /**\n     * @deprecated Use {@link VcdApiClient#_cloudApiSession}\n     */\n    private _session: BehaviorSubject<SessionType> = new BehaviorSubject<SessionType>(null);\n    private _sessionObservable: Observable<SessionType> = this._session.asObservable()\n        .pipe(\n            skipWhile(session => !session)\n        );\n    private _getSession: Observable<SessionType>;\n\n    /**\n     * CloudApi Session\n     */\n    private _cloudApiSession: BehaviorSubject<Session> = new BehaviorSubject<Session>(null);\n    private _cloudApiSessionObservable: Observable<Session> = this._cloudApiSession.asObservable()\n        .pipe(\n            skipWhile(session => !session)\n        );\n    /**\n     * This observable has a special purpose when doing automatic login during the constructor initialization.\n     * It allows backend call only after an API version is set.\n     * It also ensures that a backend call to get the current session is done once prior to any other calls.\n     *\n     * In case of an explicit cloud api auth request there is no need of this observable\n     * since this auth request will retrieve the session itself\n     */\n    private _getCloudApiSession: Observable<Session>;\n\n    private _cloudApiSessionLinks: BehaviorSubject<LinkType[]> = new BehaviorSubject<LinkType[]>([]);\n\n    /**\n     * Cached, lazy loaded observable of the AccessibleLocation array\n     */\n    private _cloudApiAccessibleLocations: Observable<AccessibleLocation[]>;\n\n    /**\n     * This property determines if it is an explicit cloud api login.\n     * In this case the old API (/api/session) should not be used at all.\n     */\n    private _isCloudApiLogin = false;\n\n    constructor(\n            private http: VcdHttpClient,\n            private injector: Injector,\n            @Optional() private config?: VcdSdkConfig,\n    ) {\n        this._baseUrl = this.injector.get(API_ROOT_URL);\n\n        let negotiatedVersion: Observable<string>;\n        if (this.config?.apiVersion) {\n            negotiatedVersion = of(this.config.apiVersion).pipe(\n                map((version) => {\n                    this.setVersion(version);\n                    return version;\n                })\n            );\n        } else {\n            negotiatedVersion = this.http.get<SupportedVersionsType>(`${this._baseUrl}/api/versions`).pipe(\n                map(versions => this.negotiateVersion(versions)),\n                tap(version => this.setVersion(version))\n            );\n        }\n        this._negotiateVersion = negotiatedVersion.pipe(\n            share({ connector: () => new ReplaySubject(1), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })\n        );\n\n        const tokenHolder: AuthTokenHolderService = this.injector.get(AuthTokenHolderService, { token: '' });\n        const token = tokenHolder.jwt ? `Bearer ${tokenHolder.jwt}` : tokenHolder.token;\n        this._getSession = this.setAuthentication(token)\n            .pipe(\n                share({ connector: () => new ReplaySubject(1), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })\n            );\n\n        this._getCloudApiSession = this.setCloudApiAuthentication(token)\n            .pipe(\n                share({ connector: () => new ReplaySubject(1), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })\n            );\n        // This is not an explicit cloud api login\n        this._isCloudApiLogin = false;\n    }\n\n    private negotiateVersion(serverVersions: SupportedVersionsType): string {\n        const supportedVersions: string[] = serverVersions.versionInfo.map(versionInfo => versionInfo.version);\n\n        // Default API Version used is the Latest API Version in VMware Cloud Director\n        return supportedVersions[supportedVersions.length - 1];\n    }\n\n    /**\n     * The purpose of this function is to ensure that prior to sending any call to the backend\n     * the version has been set and the current session has been retrieved.\n     * Note that this is important during the automatic authentication that is done during the\n     * constructor initialization, when the plugin is not required to perform its own explicit authentication\n     * but rather the ones from the underlying framework is used.\n     */\n    private validateRequestContext(): Observable<true> {\n        return (this.version ? of(this.version) : this._negotiateVersion)\n            .pipe(\n                // In case of a cloud api login we are not interested in the /api/session session\n                concatMap(() => this._isCloudApiLogin ? of(null) : this._getSession),\n                concatMap(() => this._getCloudApiSession\n                    // In case of cloud api failure we do not want to prevent further execution\n                    // for backward compatibility considerations since this may be a case\n                    // when cloud api is not supported at all for the specified version\n                    .pipe(catchError((e) => of(true)))\n                ),\n                map(() => true)\n            );\n        }\n\n    /**\n     *\n     * For use cases wich solely depends on cloudapi without any backward compatibility\n     * there should be no dependence on the old /api endpoint at all\n     */\n    private validateRequestContextCloudApiOnly(): Observable<Session> {\n        return (this.version ? of(this.version) : this._negotiateVersion).pipe(\n            concatMap(() => this._getCloudApiSession)\n        );\n    }\n\n    public setVersion(_version: string): VcdApiClient {\n        this.http.requestHeadersInterceptor.version = _version;\n        return this;\n    }\n\n    /**\n     * Global configuration for the service, that allows a provider user to execute API requests\n     * in the scope of a specific tenant.\n     *\n     * If you want to execute single API request in scope of specific tenant you can do it\n     * by passing \"X-VMWARE-VCLOUD-TENANT-CONTEXT\" header to the specific API Request.\n     *\n     * This scoping is available to query-based API calls and to bulk GET calls in the\n     * /cloudapi space.\n     *\n     * @param actAs an entityRef of the tenant (organization) to scope subsequent calls to in\n     *  the VcdApiClient, or null/no parameter to remove tenant-specific scoping\n     * @returns the current VcdApiClient instance (for chaining)\n     */\n    public actAs(actAs: EntityReferenceType = null): VcdApiClient {\n        this.http.requestHeadersInterceptor.actAs = !actAs ? null : actAs.id;\n        this.http.requestHeadersInterceptor.actAsOrgName = !actAs ? null : actAs.name;\n        return this;\n    }\n\n    /**\n     * @deprecated Use {@link VcdApiClient#setCloudApiAuthentication}\n     *\n     * Sets the authentication token to use for the VcdApiClient.\n     *\n     * After setting the token, the client will get the current session\n     * information associated with the authenticated token.\n     *\n     * @param authentication the authentication string (to be used in either the 'Authorization'\n     *  or 'x-vcloud-authorization' header)\n     * @returns the session associated with the authentication token\n     */\n    public setAuthentication(authentication: string): Observable<SessionType> {\n        if (this._isCloudApiLogin) {\n            return throwError('Only cloud api auth is allowed since it was already used');\n        }\n\n        this.http.requestHeadersInterceptor.authentication = authentication;\n        return this.http.get<SessionType>(`${this._baseUrl}/api/session`).pipe(\n                tap(session => {\n                    // automatically set actAs for provider in tenant scope\n                    if (session.org === 'System' && this.injector.get(SESSION_SCOPE) === 'tenant') {\n                        // Automatic actAs only works in versions >=9.5\n                        try {\n                            this.actAs({id: this.injector.get(SESSION_ORG_ID)});\n                        } catch (e) {\n                            console.warn('No SESSION_ORG_ID set in container. Automatic actAs is disabled.');\n                        }\n                    }\n                }),\n                tap(session => this._session.next(session))\n            );\n    }\n\n    /**\n     * Sets the authentication token to use for the VcdApiClient.\n     *\n     * After setting the token, the client will get the current session\n     * information associated with the authenticated token.\n     *\n     * @param authentication the authentication string (to be used in either the 'Authorization'\n     *  or 'x-vcloud-authorization' header)\n     *\n     * @returns session observable associated with the authentication token\n     */\n    public setCloudApiAuthentication(authentication: string): Observable<Session> {\n        this.onBeforeCloudApiAuthentication();\n\n        return of(true)\n            .pipe(\n                // Set the authentication as part of the observable in order to ensure the caller has subscribed to the observable\n                tap(() => this.http.requestHeadersInterceptor.authentication = authentication),\n                switchMap(() => this.http.get<Session>(`${this._baseUrl}/cloudapi/1.0.0/sessions/current`, { observe: 'response' })),\n            )\n            .pipe(\n                this.onCloudApiAuthentication()\n            );\n    }\n\n    public enableLogging(): VcdApiClient {\n        this.http.loggingInterceptor.enabled = true;\n\n        return this;\n    }\n\n    /**\n     * @deprecated Use {@link VcdApiClient#cloudApiLogin}\n     *\n     * Creates an authenticated session for the specified credential data.\n     *\n     * @param username the name of the user to authenticate\n     * @param tenant the organization the user belongs to\n     * @param password the password for the user\n     * @returns an authenticated session for the given credentials\n     */\n    public login(username: string, tenant: string, password: string): Observable<SessionType> {\n        if (this._isCloudApiLogin) {\n            return throwError('Only cloud api auth is allowed since it was already used');\n        }\n        const authString: string = btoa(`${username}@${tenant}:${password}`);\n\n        return this.http.post<SessionType>(\n            `${this._baseUrl}/api/sessions`,\n            null,\n            {\n                observe: 'response',\n                headers: new HttpHeaders({ Authorization: `Basic ${authString}`})\n            }\n        )\n        .pipe(\n            tap((response: HttpResponse<any>) =>\n                // tslint:disable-next-line:max-line-length\n                this.http.requestHeadersInterceptor.authentication = `${response.headers.get('x-vmware-vcloud-token-type')} ${response.headers.get('x-vmware-vcloud-access-token')}`\n            ),\n            map(response => response.body),\n            tap(session => this._session.next(session))\n        );\n    }\n\n    /**\n     * Creates an authenticated session for the specified credential data using cloud api endpoint.\n     *\n     * @param username the name of the user to authenticate\n     * @param tenant the organization the user belongs to\n     * @param password the password for the user\n     * @returns an authenticated session for the given credentials\n     */\n    public cloudApiLogin(username: string, tenant: string, password: string): Observable<Session> {\n        this.onBeforeCloudApiAuthentication();\n\n        const authString: string = btoa(`${username}@${tenant}:${password}`);\n        let url = `${this._baseUrl}/cloudapi/1.0.0/sessions`;\n        if (tenant.toLowerCase() === 'system') {\n            url += '/provider';\n        }\n        return this.http.post<Session>(\n            url,\n            null,\n            {\n                observe: 'response',\n                headers: new HttpHeaders({ [HTTP_HEADERS.Authorization]: `Basic ${authString}` })\n            }\n        ).pipe(\n            tap((response: HttpResponse<Session>) => {\n                // tslint:disable-next-line:max-line-length\n                const token = `${response.headers.get('x-vmware-vcloud-token-type')} ${response.headers.get('x-vmware-vcloud-access-token')}`;\n                this.http.requestHeadersInterceptor.authentication = token;\n            }),\n            this.onCloudApiAuthentication()\n        );\n    }\n\n    /**\n     * It is necessary to know if an explicit cloud api auth request was done.\n     * This function handles this by setting the corresponding flags, properties etc.\n     */\n    private onBeforeCloudApiAuthentication() {\n        // In case of an explicit cloud api auth request:\n        // Set the flag _isCloudApiLogin in order to know that explicit cloud api authentication is done\n        // This will help us skip code related to the old api, i.e. we should not allow explicit mix of both the api-s\n        this._isCloudApiLogin = true;\n        // In case of an explicit cloud api auth request:\n        // There is no need of _getCloudApiSession observable which is needed in the automatic login during the constructor initialization.\n        // The explicit cloud api auth request will retrieve the session.\n        this._getCloudApiSession = of(null);\n    }\n\n    /**\n     * Handle authentication.\n     * This includes getting HATEOAS links, setting the session, handling errors etc.\n     */\n    private onCloudApiAuthentication(): (source: Observable<HttpResponse<Session>>) => Observable<Session> {\n        return (source) => source.pipe(\n            tap((resp: HttpResponse<Session>) => {\n                // Get HATEOAS links\n                try {\n                    this.setCloudApiSessionLinks(parseHeaderHateoasLinks(resp.headers.get(HATEOAS_HEADER)));\n                } catch (e) {\n                    console.log('Error when parsing session HATEOAS links:', e);\n                }\n            }),\n            map(resp => resp.body),\n            tap((session: Session) => {\n                // Clear previous actAs\n                this.actAs(null);\n                // automatically set actAs for provider in tenant scope\n                if (session.org && session.org.name === 'System' && this.injector.get(SESSION_SCOPE) === 'tenant') {\n                    // Automatic actAs only works in versions >=9.5\n                    try {\n                        this.actAs({ id: this.injector.get(SESSION_ORG_ID) });\n                    } catch (e) {\n                        console.warn('No SESSION_ORG_ID set in container. Automatic actAs is disabled.');\n                    }\n                }\n            }),\n            tap((session: Session) => this._cloudApiSession.next(session)),\n            catchError((e) => {\n                this.onCloudApiAuthenticationError();\n                return throwError(e);\n            })\n        );\n    }\n\n    private onCloudApiAuthenticationError() {\n        // Clear the authentication so that any subsequent backend calls are not authenticated\n        this.http.requestHeadersInterceptor.authentication = '';\n        // _getCloudApiSession is in the center of any backend call, nullify it in order not to prevent those calls\n        // since it is easier to troubleshoot failing backend rather than no call\n        this._getCloudApiSession = of(null);\n        // Clear the links\n        this._cloudApiSessionLinks.next([]);\n        // Clear the session\n        this._cloudApiSession.next(null);\n    }\n\n    private setCloudApiSessionLinks(links: LinkType[]) {\n        this._cloudApiAccessibleLocations = null;\n        this._cloudApiSessionLinks.next(links || []);\n    }\n\n    public get<T>(endpoint: string,  options?: { headers?: HttpHeaders }): Observable<T> {\n        return this.validateRequestContext().pipe(\n            concatMap(() => this.http.get<T>(this.buildEndpointUrl(endpoint), {...options}))\n        );\n    }\n\n    public list<T>(endpoint: string, queryBuilder?: Query.Builder, multisite?: boolean | AuthorizedLocationType[], options?: { headers?: HttpHeaders }) {\n        let url = this.buildEndpointUrl(endpoint);\n\n        if (queryBuilder) {\n            url = `${url}${queryBuilder.getCloudAPI()}`;\n        }\n\n        if (multisite) {\n            if (!options) {\n                return this.http.get<T>(url, { headers: new HttpHeaders({ _multisite: this.parseMultisiteValue(multisite) }) });\n            } else if (options?.headers) {\n                options.headers.append(\"_multisite\", this.parseMultisiteValue(multisite));\n                return this.http.get<T>(url, { ...options });\n            }\n        }\n\n        return this.validateRequestContext().pipe(\n            concatMap(() => this.http.get<T>(url, { ...options }))\n        );\n    }\n\n    public createSync<T>(endpoint: string, item: T, options?: { headers?: HttpHeaders }): Observable<T> {\n        return this.validateRequestContext().pipe(\n            concatMap(() => this.http.post<T>(\n                this.buildEndpointUrl(endpoint),\n                item,\n                {...options}\n            ))\n        );\n    }\n\n    public createAsync<T>(endpoint: string, item: T, options?: { headers?: HttpHeaders }): Observable<TaskType> {\n        return this.validateRequestContext().pipe(\n            concatMap(() => this.http.post(\n                this.buildEndpointUrl(endpoint),\n                item,\n                { ...options, observe: 'response' }\n            )),\n            concatMap(response => this.mapResponseToTask(response, 'POST'))\n        );\n    }\n\n    public getTransferLink<T>(endpoint: string, item: T, transferRel: string = TRANSFER_LINK_REL): Observable<string> {\n        return this.http\n            .post(this.buildEndpointUrl(endpoint), item, { observe: 'response' })\n            .pipe(\n                map((res: HttpResponse<T & Navigable>) => {\n                    const headerLinks: LinkType[] = res.headers.has(HATEOAS_HEADER)\n                        ? parseHeaderHateoasLinks(res.headers.get(HATEOAS_HEADER))\n                        : [];\n                    const links: LinkType[] = res.body ? (res.body.link || []) : [];\n                    const link = [...headerLinks, ...links]\n                        .find((l) => l.rel === transferRel);\n                    if (!link) {\n                        throw new ClientError(\n                          `Response from ${endpoint} did not contain a transfer link`,\n                          ClientErrorType.HateoasLinkMissing\n                        );\n                    }\n                    return link.href;\n                })\n            );\n    }\n\n    public startTransfer<T>(endpoint: string, item: T, transferRel: string = TRANSFER_LINK_REL): Observable<VcdTransferClient> {\n        return this.getTransferLink(endpoint, item, transferRel)\n            .pipe(\n                map((transferUrl) => new VcdTransferClient(this.http, transferUrl))\n            );\n    }\n\n    public updateSync<T>(endpoint: string, item: T, options?: { headers?: HttpHeaders }): Observable<T> {\n        return this.validateRequestContext().pipe(\n            concatMap(() => this.http.put<T>(\n                this.buildEndpointUrl(endpoint),\n                item,\n                { ...options }\n            ))\n        );\n    }\n\n    public updateAsync<T>(endpoint: string, item: T, options?: { headers?: HttpHeaders }): Observable<TaskType> {\n\n        return this.validateRequestContext().pipe(\n            concatMap(() => this.http.put(\n                this.buildEndpointUrl(endpoint),\n                item,\n                { ...options, observe: 'response' }\n            )),\n            concatMap(response => this.mapResponseToTask(response, 'PUT'))\n        );\n    }\n\n    public deleteSync(endpoint: string, options?: { headers?: HttpHeaders }): Observable<void> {\n        return this.validateRequestContext().pipe(\n            concatMap(() => this.http.delete<void>(this.buildEndpointUrl(endpoint), { ...options }))\n        );\n    }\n\n    public deleteAsync(endpoint: string, options?: { headers?: HttpHeaders }): Observable<TaskType> {\n        return this.validateRequestContext().pipe(\n            concatMap(() => this.http.delete(this.buildEndpointUrl(endpoint), { ...options, observe: 'response' })),\n            concatMap(response => this.mapResponseToTask(response, 'DELETE'))\n        );\n    }\n\n    private mapResponseToTask(response: HttpResponse<any>, httpVerb: string): Observable<TaskType> {\n        if (response.headers.has('Location') && response.status === 202) {\n            return this.http.get<TaskType>(response.headers.get('Location'));\n        } else if (response.body && response.body.type.startsWith('application/vnd.vmware.vcloud.task+')) {\n            const task: TaskType = Object.assign(new TaskType(), response.body);\n            return of(task);\n        }\n\n        return throwError(() => new ClientError(\n          `An asynchronous request was made to [${httpVerb} ${response.url}], but no task was returned.  The operation may still have been successful.`,\n            ClientErrorType.TaskLinkMissing\n        ));\n    }\n\n    public getEntity<T extends EntityReferenceType>(entityRef: EntityReferenceType): Observable<T>;\n    // tslint:disable-next-line:unified-signatures\n    public getEntity<T extends EntityReferenceType>(urn: string): Observable<T>;\n    public getEntity<T extends EntityReferenceType>(entityRefOrUrn: EntityReferenceType | string): Observable<T> {\n        const entityResolver: Observable<EntityType> = typeof entityRefOrUrn === 'string' ?\n            this.http.get<EntityType>(`${this._baseUrl}/api/entity/${entityRefOrUrn}`) :\n            this.http.get<EntityType>(`${this._baseUrl}/api/entity/urn:vcloud:${entityRefOrUrn.type}:${entityRefOrUrn.id}`);\n\n        return this.validateRequestContext().pipe(\n            concatMap(() => entityResolver),\n            concatMap(entity => this.http.get<T>(`${entity.link[0].href}`))\n        );\n    }\n\n    public updateTask(task: TaskType, options?: { headers?: HttpHeaders }): Observable<TaskType> {\n        return this.validateRequestContext().pipe(\n            concatMap(() => this.http.get<TaskType>(task.href, { ...options }))\n        );\n    }\n\n    public isTaskComplete(task: TaskType): boolean {\n        return ['success', 'error', 'canceled', 'aborted'].indexOf(task.status) > -1;\n    }\n\n    public removeItem(item: Navigable, options?: { headers?: HttpHeaders }): Observable<TaskType> {\n        const link: LinkType = this.findLink(item, 'remove', null);\n        if (!link) {\n            return throwError(() => new ClientError(\n              `No 'remove' link for specified resource.`,\n              ClientErrorType.HateoasLinkMissing\n            ));\n        }\n\n        return this.validateRequestContext().pipe(\n            concatMap(() => this.http.delete<TaskType>(link.href, { ...options }))\n        );\n    }\n\n    /**\n     * Queries the VMware Cloud Director API based on the specified Query.Builder instance.\n     *\n     * @param builder An definition of the query to construct (type, filter, page size, etc.)\n     * @param multisite a flag indicating whether or not to fan the query out to all available sites\n     * @returns a query result for the specified query\n     */\n    public query<T>(builder: Query.Builder, multisite?: boolean, options?: { headers?: HttpHeaders }): Observable<T>;\n    /**\n     * Queries the VMware Cloud Director API based on the specified Query.Builder instance.\n     *\n     * @param builder An definition of the query to construct (type, filter, page size, etc.)\n     * @param multisite the set of site locations to include in the query fanout\n     * @returns a query result for the specified query\n     */\n    // tslint:disable-next-line:unified-signatures\n    public query<T>(builder: Query.Builder, multisite?: AuthorizedLocationType[], options?: { headers?: HttpHeaders }): Observable<T>;\n    public query<T>(builder: Query.Builder, multisite?: any, options?: { headers?: HttpHeaders }): Observable<T> {\n        return this.getQueryPage(`${this._baseUrl}/api/query${builder.get()}`, multisite, options);\n    }\n\n    /**\n     * Queries the VMware Cloud Director API for the first page of the provided result set.\n     *\n     * @param result the result set to retrieve the first page of records for\n     * @param multisite a flag indicating whether or not to fan the query out to all available sites\n     * @returns the records for the first page of the query\n     */\n    public firstPage<T>(result: T, multisite?: boolean, options?: { headers?: HttpHeaders }): Observable<T>;\n    /**\n     * Queries the VMware Cloud Director API for the first page of the provided result set.\n     *\n     * @param result the result set to retrieve the first page of records for\n     * @param multisite the set of site locations to include in the query fanout\n     * @returns the records for the first page of the query\n     */\n    // tslint:disable-next-line:unified-signatures\n    public firstPage<T>(result: T, multisite?: AuthorizedLocationType[], options?: { headers?: HttpHeaders }): Observable<T>;\n    public firstPage<T>(result: T, multisite?: any, options?: { headers?: HttpHeaders }): Observable<T> {\n        const link: LinkType = this.findLink(result, 'firstPage', (result as ResourceType).type);\n        if (!link) {\n            return throwError(() => new ClientError(\n              `No 'firstPage' link for specified query.`,\n              ClientErrorType.HateoasLinkMissing\n            ));\n        }\n\n        return this.getQueryPage(link.href, multisite, options);\n    }\n\n    public hasFirstPage<T>(result: T): boolean {\n        return !!this.findLink(result, 'firstPage', (result as ResourceType).type);\n    }\n\n    /**\n     * Queries the VMware Cloud Director API for the previous page of the provided result set.\n     *\n     * @param result the result set to retrieve the previous page of records for\n     * @param multisite a flag indicating whether or not to fan the query out to all available sites\n     * @returns the records for the previous page of the query\n     */\n    public previousPage<T>(result: T, multisite?: boolean, options?: { headers?: HttpHeaders }): Observable<T>;\n    /**\n     * Queries the VMware Cloud Director API for the previous page of the provided result set.\n     *\n     * @param result the result set to retrieve the previous page of records for\n     * @param multisite the set of site locations to include in the query fanout\n     * @returns the records for the previous page of the query\n     */\n    // tslint:disable-next-line:unified-signatures\n    public previousPage<T>(result: T, multisite?: AuthorizedLocationType[], options?: { headers?: HttpHeaders }): Observable<T>;\n    public previousPage<T>(result: T, multisite?: any, options?: { headers?: HttpHeaders }): Observable<T> {\n        const link: LinkType = this.findLink(result, 'previousPage', (result as ResourceType).type);\n        if (!link) {\n            return throwError(() => new ClientError(\n              `No 'previousPage' link for specified query.`,\n              ClientErrorType.HateoasLinkMissing\n              ));\n        }\n\n        return this.getQueryPage(link.href, multisite, options);\n    }\n\n    public hasPreviousPage<T>(result: T): boolean {\n        return !!this.findLink(result, 'previousPage', (result as ResourceType).type);\n    }\n\n    /**\n     * Queries the VMware Cloud Director API for the next page of the provided result set.\n     *\n     * @param result the result set to retrieve the next page of records for\n     * @param multisite a flag indicating whether or not to fan the query out to all available sites\n     * @returns the records for the next page of the query\n     */\n    public nextPage<T>(result: T, multisite?: boolean, options?: { headers?: HttpHeaders }): Observable<T>;\n    /**\n     * Queries the VMware Cloud Director API for the next page of the provided result set.\n     *\n     * @param result the result set to retrieve the next page of records for\n     * @param multisite the set of site locations to include in the query fanout\n     * @returns the records for the next page of the query\n     */\n    // tslint:disable-next-line:unified-signatures\n    public nextPage<T>(result: T, multisite?: AuthorizedLocationType[], options?: { headers?: HttpHeaders }): Observable<T>;\n    public nextPage<T>(result: T, multisite?: any, options?: { headers?: HttpHeaders }): Observable<T> {\n        const link: LinkType = this.findLink(result, 'nextPage', (result as ResourceType).type);\n        if (!link) {\n            return throwError(() => new ClientError(\n              `No 'nextPage' link for specified query.`,\n              ClientErrorType.HateoasLinkMissing\n              ));\n        }\n\n        return this.getQueryPage<T>(link.href, multisite, options);\n    }\n\n    public hasNextPage<T>(result: T): boolean {\n        return !!this.findLink(result, 'nextPage', (result as ResourceType).type);\n    }\n\n    /**\n     * Queries the VMware Cloud Director API for the last page of the provided result set.\n     *\n     * @param result the result set to retrieve the last page of records for\n     * @param multisite a flag indicating whether or not to fan the query out to all available sites\n     * @returns the records for the last page of the query\n     */\n    public lastPage<T>(result: T, multisite?: boolean, options?: { headers?: HttpHeaders }): Observable<T>;\n    /**\n     * Queries the VMware Cloud Director API for the last page of the provided result set.\n     *\n     * @param result the result set to retrieve the last page of records for\n     * @param multisite the set of site locations to include in the query fanout\n     * @returns the records for the last page of the query\n     */\n    // tslint:disable-next-line:unified-signatures\n    public lastPage<T>(result: T, multisite?: AuthorizedLocationType[], options?: { headers?: HttpHeaders }): Observable<T>;\n    public lastPage<T>(result: T, multisite?: any, options?: { headers?: HttpHeaders }): Observable<T> {\n        const link: LinkType = this.findLink(result, 'lastPage', (result as ResourceType).type);\n        if (!link) {\n            return throwError(() => new ClientError(\n              `No 'lastPage' link for specified query.`,\n              ClientErrorType.HateoasLinkMissing\n            ));\n        }\n\n        return this.getQueryPage(link.href, multisite, options);\n    }\n\n    public hasLastPage<T>(result: T): boolean {\n        return !!this.findLink(result, 'lastPage', (result as ResourceType).type);\n    }\n\n    private getQueryPage<T>(href: string, multisite?: any, options?: { headers?: HttpHeaders }): Observable<T> {\n        if (multisite) {\n            if (!options) {\n                return this.http.get<T>(href, { headers: new HttpHeaders({ _multisite: this.parseMultisiteValue(multisite) }) })\n            } else if (options?.headers) {\n                options.headers.append(\"_multisite\", this.parseMultisiteValue(multisite));\n                return this.http.get<T>(href, { ...options })\n            }\n        }\n\n        return this.validateRequestContext().pipe(\n            concatMap(() => this.http.get<T>(href, { ...options }))\n        );\n    }\n\n  /**\n   * Use to perform action availability check before calling the API\n   * @param item - the navigable item (containing link collection)\n   * @param linkRelType - the link rel type, pass either LinkRelType or string\n   * @param entityRefType - the entity reference type\n   */\n    public canPerformAction(item: Navigable, linkRelType: LinkRelType | string, entityRefType?: string): boolean {\n        return !!this.findLink(item, linkRelType, entityRefType);\n    }\n\n    private findLink(item: Navigable, rel: string, type: string): LinkType {\n        if (!item || !item.link) {\n            return undefined;\n        }\n\n        return item.link.find((link) => {\n            if (type) {\n                return link.rel.includes(rel) && link.type === type;\n            }\n\n            return link.rel.includes(rel);\n        });\n    }\n\n    private parseMultisiteValue(multisite: boolean | AuthorizedLocationType[]): string {\n        return typeof multisite === 'boolean' ? (multisite ? 'global' : 'local') : multisite.map(site => site.locationId).join(',');\n    }\n\n    /**\n     * @deprecated Use cloudApiSession\n     */\n    public get session(): Observable<SessionType> {\n        return this.validateRequestContext().pipe(\n            concatMap(() => this._sessionObservable)\n        );\n    }\n\n    /**\n     * Get Session observable\n     */\n    public get cloudApiSession(): Observable<Session> {\n        return this.validateRequestContextCloudApiOnly().pipe(\n            concatMap(() => this._cloudApiSessionObservable)\n        );\n    }\n\n    public get username(): Observable<string> {\n        return merge(\n                this.cloudApiSession.pipe(\n                    filter(() => this._isCloudApiLogin),\n                    map(session => session && session.user && session.user.name)\n                ),\n                this.session.pipe(\n                    filter(() => !this._isCloudApiLogin),\n                    map(session => session && session.user)\n                )\n            );\n    }\n\n    public get organization(): Observable<string> {\n        return merge(\n            this.cloudApiSession.pipe(\n                filter(() => this._isCloudApiLogin),\n                map(session => session && session.org && session.org.name)\n            ),\n            this.session.pipe(\n                filter(() => !this._isCloudApiLogin),\n                map(session => session && session.org)\n            )\n        );\n    }\n\n    /**\n     * @deprecated Use cloudApiLocation\n     */\n    public get location(): Observable<AuthorizedLocationType> {\n        return this.session.pipe(\n            map(session => session.authorizedLocations.location.find(location => location.locationId === session.locationId))\n        );\n    }\n\n    /**\n     * Gets the location corresponding to the current session\n     */\n    public get cloudApiLocation(): Observable<AccessibleLocation> {\n        return this.cloudApiSession.pipe(\n            switchMap(() => {\n                if (!this._cloudApiAccessibleLocations) {\n                    // Ensure caching for getting AccessibleLocations\n                    this._cloudApiAccessibleLocations = this._cloudApiSessionLinks\n                        .pipe(\n                            // Get the AccessibleLocations link\n                            map((links) => this.findLink({ link: links }, 'down', 'AccessibleLocations')),\n                            // Fetch AccessibleLocations from the backend\n                            switchMap((link: LinkType) => link ? this.http.get<AccessibleLocations>(link.href) : of(null)),\n                            // Get the array with all locations (what if there are many pages)\n                            map((accessibleLocations: AccessibleLocations) => accessibleLocations && accessibleLocations.values)\n                        )\n                        .pipe(\n                            share({ connector: () => new ReplaySubject(1), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })\n                        );\n                }\n                return this._cloudApiAccessibleLocations;\n            }),\n\n            // Need to have the session in order to get its location\n            withLatestFrom(this.cloudApiSession),\n            // Find the location that corresponds to this session\n            map(([accessibleLocations, session]) => {\n                if (!accessibleLocations || !session) {\n                    return null;\n                }\n                const sessionLocation = session.location;\n                if (!sessionLocation) {\n                    return null;\n                }\n                return accessibleLocations.find(location => location.locationId === sessionLocation);\n            }),\n        );\n    }\n\n    public getLocation(session: SessionType): AuthorizedLocationType {\n        return session.authorizedLocations.location.find(location => location.locationId === session.locationId);\n    }\n\n    /**\n     * Build the endpoint url. If the provided endpoint is already an absolute URL, then return it as it is without\n     * any modifications, otherwise consider it as a relative one and prepend the baseUrl as defined by the host application.\n     */\n    private buildEndpointUrl(endpoint: string): string {\n        return endpoint.indexOf('://') > -1 ? endpoint : `${this._baseUrl}/${endpoint}`;\n    }\n\n}\n"]}