@vcd/sdk 0.13.0 → 15.0.0-alpha.0

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

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

package/client/client/constants.d.ts

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

package/client/client/index.d.ts

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

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

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

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

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

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

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

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

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

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

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

package/client/client/vcd.transfer.client.d.ts

@@ -0,0 +1,121 @@
+import { Observable, Observer } from 'rxjs';
+import { VcdHttpClient } from './vcd.http.client';
+/**
+ * Default chunk size is 50MiB.  This is equal to the chunk size the VCD UI uses for library uploads.
+ */
+export declare const MAX_CHUNK_SIZE: number;
+/**
+ * How many times to retry a chunk upload.
+ */
+export declare const MAX_CHUNK_RETRY_COUNT = 5;
+/**
+ * Details about a completed file transfer.
+ */
+export interface TransferResult {
+    /**
+     * Filename being transferred.
+     */
+    filename: string | '<blob>';
+    /**
+     * URL being used for the transfer.
+     */
+    transferUrl: string;
+    /**
+     * How many retries in total were required
+     */
+    retryCount: number;
+    /**
+     * The number of chunks that have been sent.
+     */
+    chunksSent: number;
+    /**
+     * How many bytes have been sent.
+     */
+    bytesSent: number;
+    /**
+     * How many milliseconds that have elapsed since starting the transfer.
+     */
+    timeTakenMs: number;
+}
+/**
+ * Details about a file transfer in progress.
+ */
+export interface TransferProgress {
+    /**
+     * Filename being transferred.
+     */
+    filename: string | '<blob>';
+    /**
+     * URL being used for the transfer.
+     */
+    transferUrl: string;
+    /**
+     * The current retry number for the current chunk.
+     */
+    retryNumber: number;
+    /**
+     * The number of retries in total.
+     */
+    retryCount: number;
+    /**
+     * The number of chunks that have been sent.
+     */
+    chunksSent: number;
+    /**
+     * The number of chunks remaining.
+     */
+    chunksRemaining: number;
+    /**
+     * How many bytes have been sent.
+     */
+    bytesSent: number;
+    /**
+     * How many bytes remaining to be sent.
+     */
+    bytesRemaining: number;
+    /**
+     * Percentage completion.
+     */
+    percent: number;
+    /**
+     * How many milliseconds that have elapsed since starting the transfer.
+     */
+    timeTakenMs: number;
+    /**
+     * Naive estimate of time remaining.  This is not scientific at all - a simple linear extrapolation.
+     */
+    estimatedTimeRemainingMs: number;
+}
+/**
+ * A special error thrown by the transfer client.  It gives access to the causing error, and the final progress
+ * before the error occurred.
+ */
+export declare class TransferError extends Error {
+    readonly originalError: any;
+    readonly lastProgress: TransferProgress;
+    constructor(message: string, originalError: any, lastProgress: TransferProgress);
+}
+/**
+ * This is used to upload files to a VCD API transfer URL.  It is not suggested to create this class - instead
+ * use the startTransfer method in VcdApiClient.
+ */
+export declare class VcdTransferClient {
+    httpClient: VcdHttpClient;
+    transferUrl: string;
+    maxChunkSize: number;
+    maxChunkRetryCount: number;
+    /**
+     * Create a transfer client.
+     * @param httpClient the http client to be used
+     * @param transferUrl the URL to upload to
+     */
+    constructor(httpClient: VcdHttpClient, transferUrl: string, maxChunkSize?: number, maxChunkRetryCount?: number);
+    /**
+     * Upload data, optionally listening for progress updates.
+     * @param source what to upload.
+     * @param progressObserver (optional) this will get progress notifications during the upload
+     * @returns fetails of the finished upload.
+     * @throws TransferError when a chunk upload fails.
+     */
+    upload(source: Blob | File, progressObserver?: Observer<TransferProgress>): Observable<TransferResult>;
+}

package/client/container-hooks/index.d.ts

@@ -0,0 +1,58 @@
+/**
+ * This is the currently supported - albeit very minimal - public SDK.
+ */
+import { InjectionToken } from '@angular/core';
+/**
+ * Wire in as a string.  Gives the root URL for API access (for example, the load balancer URL
+ * or the single-cell URL).
+ */
+export declare const API_ROOT_URL: InjectionToken<string>;
+/**
+ * Wire in as a string.  Gives the root URL for the legacy Flex application.
+ */
+export declare const FLEX_APP_URL: InjectionToken<string>;
+/**
+ * Wire in as a string.  Gives the current scope of the VCD-UI.  As of current, this will be
+ * either 'tenant' for the tenant portal, or 'service-provider' for the service-provider portal.
+ */
+export declare const SESSION_SCOPE: InjectionToken<string>;
+/**
+ * Wire in as a string.  Gives the unique name (not the display name) of the current tenant
+ * organization that the VCD-UI is being used for.
+ */
+export declare const SESSION_ORGANIZATION: InjectionToken<string>;
+/**
+ * Wire in as a string.  Gives the UUID identifier of the current tenant
+ * organization that the VCD-UI is being used for.
+ */
+export declare const SESSION_ORG_ID: InjectionToken<string>;
+/**
+ * Wire in as a string.  Gives the full root path for module assets (e.g. images, scripts, text files)
+ *
+ * ATTENTION!
+ * Add || new InjectionToken to workaround the Angular security mechanics which prevent use of injection tokens
+ * which potentially are not defiend. The same fix can be applied for the rest tokens if needed.
+ */
+export declare const EXTENSION_ASSET_URL: InjectionToken<string>;
+/**
+ * Wire in as a string.  Gives the Angular 2 route that the module is registered under.
+ */
+export declare const EXTENSION_ROUTE: InjectionToken<string>;
+/**
+ * Wire in as a boolean.  True if running under the SDK, false if running in production.
+ */
+export declare const SDK_MODE: InjectionToken<boolean>;
+/**
+ * Inject this to access the authentication token.
+ */
+export interface AuthTokenHolderService {
+    /**
+     * The authentication token.
+     */
+    token: string;
+    /**
+     * JWT token
+     */
+    jwt?: string;
+}
+export declare const AuthTokenHolderService: AuthTokenHolderService;