@c8y/client 1018.487.7 → 1018.497.2

package/lib/cjs/src/audit/IAuditRecord.d.ts

@@ -0,0 +1,36 @@
+import { IEvent } from '../event';
+import { Severity } from '../core';
+import { AuditRecordType } from './AuditRecordType';
+import { IChange } from './IChange';
+/**
+ * IAuditRecord implements the IEvent interface.
+ * Keep in mind that the mandantory fragments from IEvent are
+ * also mandantory for IAuditRecord.
+ */
+export interface IAuditRecord extends IEvent {
+    /**
+     * User which created the audit record
+     */
+    user?: string;
+    /**
+     * To which application the record belongs to
+     */
+    application?: string;
+    /**
+     * Description what the audit record is about
+     */
+    activity?: string;
+    /**
+     * Severity of the record
+     */
+    severity?: Severity;
+    /**
+     * A specific type to which the record belongs to
+     */
+    type: AuditRecordType;
+    /**
+     * Change status of the record
+     */
+    changes?: Set<IChange>;
+}
+//# sourceMappingURL=IAuditRecord.d.ts.map

package/lib/cjs/src/audit/IChange.d.ts

@@ -0,0 +1,28 @@
+import { ChangeType } from './ChangeType';
+/**
+ * IChange interface belongs to IAuditRecord and
+ * keeps track what type and which attributes are changed.
+ */
+export interface IChange {
+    /**
+     * Which attribute was touched
+     */
+    attribute: string;
+    /**
+     * Of which type
+     */
+    type: string;
+    /**
+     * Which value was set before
+     */
+    previousValue: any;
+    /**
+     * What is the current value
+     */
+    newValue: any;
+    /**
+     * Of which type was the change, see [[ChangeType]]
+     */
+    changeType: ChangeType;
+}
+//# sourceMappingURL=IChange.d.ts.map

package/lib/cjs/src/audit/index.d.ts

@@ -0,0 +1,6 @@
+export * from './AuditService';
+export * from './IAuditRecord';
+export * from './AuditRecordType';
+export * from './IChange';
+export * from './ChangeType';
+//# sourceMappingURL=index.d.ts.map

package/lib/cjs/src/core/BasicAuth.d.ts

@@ -0,0 +1,25 @@
+import { IAuthentication, ICredentials } from './IAuthentication';
+/**
+ * Allows to use Basic-Auth for Authorization to the
+ * Cumulocity API.
+ */
+export declare class BasicAuth implements IAuthentication {
+    user: string;
+    /**
+     * Authenticates the given user against the given tenant.
+     * @param name
+     * @param password
+     * @param tenant
+     */
+    constructor(credentials?: ICredentials);
+    updateCredentials({ tenant, user, password, token, tfa }?: ICredentials): string;
+    getFetchOptions(options: any): any;
+    getCometdHandshake(config?: {
+        ext?: object;
+    }): {
+        ext?: object;
+    };
+    logout(): void;
+    private getCookieValue;
+}
+//# sourceMappingURL=BasicAuth.d.ts.map

package/lib/cjs/src/core/BearerAuth.d.ts

@@ -0,0 +1,13 @@
+import { IAuthentication, ICredentials } from './IAuthentication';
+export declare class BearerAuth implements IAuthentication {
+    constructor(token?: string);
+    getFetchOptions(options: any): any;
+    updateCredentials({ token }: ICredentials): undefined;
+    getCometdHandshake(config?: {
+        ext?: any;
+    }): {
+        ext?: any;
+    };
+    logout(): void;
+}
+//# sourceMappingURL=BearerAuth.d.ts.map

package/lib/cjs/src/core/CookieAuth.d.ts

@@ -0,0 +1,19 @@
+import { IAuthentication, ICredentials } from './IAuthentication';
+/**
+ * Allows to use Cookies for Authorization to the
+ * Cumulocity API.
+ */
+export declare class CookieAuth implements IAuthentication {
+    user: string;
+    private logoutUrl;
+    updateCredentials({ user }?: ICredentials): string;
+    getFetchOptions(options: any): any;
+    getCometdHandshake(config?: {
+        ext?: object;
+    }): {
+        ext?: object;
+    };
+    logout(): Promise<import("./IFetchResponse").IFetchResponse>;
+    private getCookieValue;
+}
+//# sourceMappingURL=CookieAuth.d.ts.map

package/lib/cjs/src/core/FetchClient.d.ts

@@ -0,0 +1,18 @@
+import { IFetchClient } from './IFetchClient';
+import { IFetchOptions } from './IFetchOptions';
+import { IFetchResponse } from './IFetchResponse';
+import { IAuthentication } from './IAuthentication';
+export declare class FetchClient implements IFetchClient {
+    baseUrl?: string;
+    tenant: string;
+    defaultHeaders: {};
+    constructor(authOrBaseUrl?: IAuthentication | string, baseUrl?: string);
+    setAuth(auth: IAuthentication): void;
+    fetch(url: string, init?: IFetchOptions): Promise<IFetchResponse>;
+    getUrl(url?: string, options?: IFetchOptions): string;
+    getFetchOptions(options?: IFetchOptions): IFetchOptions;
+    getCometdHandshake(config?: any): any;
+    private resolveServerUrl;
+    private adjustOptionsForFormData;
+}
+//# sourceMappingURL=FetchClient.d.ts.map

package/lib/cjs/src/core/IAuthentication.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Used for header based Authentication.
+ */
+export interface IAuthentication {
+    updateCredentials(credentials: ICredentials): string | undefined;
+    getFetchOptions(options?: object): object;
+    getCometdHandshake(config?: object): object;
+    logout(): any;
+}
+export interface ICredentials {
+    tenant?: string;
+    user?: string;
+    password?: string;
+    token?: string;
+    tfa?: string;
+    [key: string]: any;
+}
+export interface IMicroserviceClientRequestHeaders {
+    cookie?: string;
+    authorization?: string;
+    [key: string]: any;
+}
+//# sourceMappingURL=IAuthentication.d.ts.map

package/lib/cjs/src/core/ICustomProperties.d.ts

@@ -0,0 +1,8 @@
+/** Description of ICustomProperties interface */
+export interface ICustomProperties {
+    /** Any keys */
+    [key: string]: any;
+    /** Link to this Resource - optional property */
+    self?: string;
+}
+//# sourceMappingURL=ICustomProperties.d.ts.map

package/lib/cjs/src/core/ICustomPropertiesMap.d.ts

@@ -0,0 +1,5 @@
+import { ICustomProperties } from './';
+export interface ICustomPropertiesMap {
+    customProperties: ICustomProperties;
+}
+//# sourceMappingURL=ICustomPropertiesMap.d.ts.map

package/lib/cjs/src/core/IFetchClient.d.ts

@@ -0,0 +1,10 @@
+import { IFetchOptions } from './IFetchOptions';
+import { IFetchResponse } from './IFetchResponse';
+export interface IFetchClient {
+    tenant?: string;
+    fetch(url: string, init?: IFetchOptions): Promise<IFetchResponse>;
+    getFetchOptions(options?: IFetchOptions): IFetchOptions;
+    getCometdHandshake(config?: any): any;
+    getUrl(url: string, options?: IFetchOptions): string;
+}
+//# sourceMappingURL=IFetchClient.d.ts.map

package/lib/cjs/src/core/IFetchOptions.d.ts

@@ -0,0 +1,21 @@
+import FormData from 'form-data';
+/**
+ * Data that you want to pass into your request. Based on
+ * fetch RequestInit.
+ */
+export interface IFetchOptions extends Omit<RequestInit, 'body'> {
+    /**
+     * Parameters added to the url
+     */
+    params?: object;
+    /**
+     * The headers to attach
+     */
+    headers?: HeadersInit | any;
+    body?: FormData | RequestInit['body'];
+    /**
+     * Parameters added as body
+     */
+    [key: string]: any;
+}
+//# sourceMappingURL=IFetchOptions.d.ts.map

package/lib/cjs/src/core/IFetchResponse.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Response from server
+ */
+export interface IFetchResponse extends Response {
+    /**
+     * HTTP status code
+     */
+    status: number;
+    /**
+     * HTTP headers
+     */
+    headers: Headers;
+    /**
+     * Data in arrayBuffer format
+     */
+    arrayBuffer(): Promise<ArrayBuffer>;
+    /**
+     * Data in json format
+     */
+    json(): Promise<any>;
+    /**
+     * Data in text format
+     */
+    text(): Promise<string>;
+}
+//# sourceMappingURL=IFetchResponse.d.ts.map

package/lib/cjs/src/core/IIdentified.d.ts

@@ -0,0 +1,6 @@
+export interface IIdentified {
+    id?: string | number;
+    toJSON?(): any;
+    [key: string]: any;
+}
+//# sourceMappingURL=IIdentified.d.ts.map

package/lib/cjs/src/core/IMicroserviceSubscriptions.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Response returned by the microservice subscription endpoint.
+ * Contains an array of credentials that can be used to access subscribed tenants.
+ */
+export interface IMicroserviceSubscriptionsResponse {
+    users: IMicroserviceSubscription[];
+}
+/**
+ * Not to be confused with ICredentials as 'name' is used instead of 'user' for the username.
+ */
+export interface IMicroserviceSubscription {
+    tenant: string;
+    name: string;
+    password: string;
+}
+//# sourceMappingURL=IMicroserviceSubscriptions.d.ts.map

package/lib/cjs/src/core/INamed.d.ts

@@ -0,0 +1,5 @@
+import { IIdentified } from './IIdentified';
+export interface INamed extends IIdentified {
+    name: string;
+}
+//# sourceMappingURL=INamed.d.ts.map

package/lib/cjs/src/core/IResult.d.ts

@@ -0,0 +1,26 @@
+import { IFetchResponse } from './IFetchResponse';
+import { IResultBase } from './IResultBase';
+/**
+ * The IResult interface splits up the server
+ * response in different fragments, namely in:
+ *  + data
+ *  + res
+ *
+ * @param TData generic type
+ */
+export interface IResult<TData> extends IResultBase<TData> {
+    /**
+     * Holds the data from server response in a generic way.
+     * TData could be of any type, for example:
+     * + [[IManagedObject]]
+     * + [[IAlarm]]
+     * + [[IAuditRecord]]
+     * + ...
+     */
+    data: TData;
+    /**
+     * Server response of type [[IFetchResponse]].
+     */
+    res: IFetchResponse;
+}
+//# sourceMappingURL=IResult.d.ts.map

package/lib/cjs/src/core/IResultBase.d.ts

@@ -0,0 +1,6 @@
+import { Paging } from './Paging';
+export interface IResultBase<TData> {
+    data: TData | TData[];
+    paging?: Paging<TData>;
+}
+//# sourceMappingURL=IResultBase.d.ts.map

package/lib/cjs/src/core/IResultList.d.ts

@@ -0,0 +1,36 @@
+import { IFetchResponse } from './IFetchResponse';
+import { Paging } from './Paging';
+import { IResultBase } from './IResultBase';
+/**
+ * The IResultList<TData> interface splits up the server
+ * response in different fragments, namely in:
+ *  + data[]
+ *  + paging
+ *  + res
+ *
+ * @param TData generic type
+ */
+export interface IResultList<TData> extends IResultBase<TData> {
+    /**
+     * Holds the data from server response in a generic way.
+     * TData could be of any type, for example:
+     * + [[IManagedObject]]
+     * + [[IAlarm]]
+     * + [[IAuditRecord]]
+     * + ...
+     *
+     * Response data as array.
+     */
+    data: TData[];
+    /**
+     * Server response of type [[IFetchResponse]].
+     */
+    res: IFetchResponse;
+    /**
+     * Paging allows you to query the next and previous data chunks
+     * in a convenient way. You can also go to a specific page or just read
+     * page information about the current data chunk. For a detailed view see [[Paging]]
+     */
+    paging?: Paging<TData>;
+}
+//# sourceMappingURL=IResultList.d.ts.map

package/lib/cjs/src/core/ISource.d.ts

@@ -0,0 +1,18 @@
+/**
+ * ISource can be used when an id is mandantory.
+ */
+export interface ISource {
+    /**
+     * Unique identifier
+     */
+    id: string;
+    /**
+     * Name of the resource
+     */
+    name?: string;
+    /**
+     * Link to the resource
+     */
+    self?: string;
+}
+//# sourceMappingURL=ISource.d.ts.map

package/lib/cjs/src/core/MicroserviceClientRequestAuth.d.ts

@@ -0,0 +1,32 @@
+import { IAuthentication, IMicroserviceClientRequestHeaders } from './IAuthentication';
+/**
+ * Allows to use either Cookie-Auth or Basic-Auth
+ * of a microservice client request header
+ * for Authorization to the Cumulocity API.
+ */
+export declare class MicroserviceClientRequestAuth implements IAuthentication {
+    protected authTokenFromCookie: string | undefined;
+    protected authTokenFromHeader: string | undefined;
+    protected xsrfToken: string | undefined;
+    /**
+     * Authenticates using the credentials which were
+     * provided within the request headers of the
+     * client call to the microservice.
+     * @param headers
+     */
+    constructor(headers?: IMicroserviceClientRequestHeaders);
+    updateCredentials(): string;
+    getFetchOptions(options: any): any;
+    getCometdHandshake(config?: {
+        ext?: {
+            [key: string]: any;
+        };
+    }): {
+        ext?: {
+            [key: string]: any;
+        };
+    };
+    logout(): void;
+    protected getCookieValue(headers: IMicroserviceClientRequestHeaders, name: string): string;
+}
+//# sourceMappingURL=MicroserviceClientRequestAuth.d.ts.map

package/lib/cjs/src/core/NodeJSCookieAuth.d.ts

@@ -0,0 +1,11 @@
+import { IFetchResponse } from './IFetchResponse';
+import { MicroserviceClientRequestAuth } from './MicroserviceClientRequestAuth';
+/**
+ * Extracts the `authorization` cookie from the `set-cookie` header of a response.
+ *
+ * Meant to be used in none browser environments like nodejs which don't deal with cookies.
+ */
+export declare class NodeJSCookieAuth extends MicroserviceClientRequestAuth {
+    constructor(cookieResponse: IFetchResponse);
+}
+//# sourceMappingURL=NodeJSCookieAuth.d.ts.map

package/lib/cjs/src/core/Paging.d.ts

@@ -0,0 +1,63 @@
+import { Service } from './Service';
+import { IResultList } from './IResultList';
+/**
+ * Paging allows you to query the next and previous data chunks
+ * in a convenient way. You can also go to a specific page or just read
+ * page information about the current data chunk.
+ * Note that page numbers are generated by backend
+ * and may be used as offset rather than a continuous range of positive numbers
+ * (e.g. in case of users with restricted permissions).
+ */
+export declare class Paging<TData> {
+    /**
+     * Holds the number of the current page, so in fact
+     * the data chunk you are looking at.
+     */
+    currentPage: number;
+    /**
+     * Holds the number of the next page.
+     */
+    nextPage: number;
+    /**
+     * Holds the number of the previous page.
+     */
+    prevPage: number;
+    /**
+     * Holds the number of the maximum data that you will
+     * get with the response.
+     */
+    pageSize: number;
+    /**
+     * Holds the number of total pages regarding to the
+     * given page size.
+     */
+    totalPages: number;
+    private service;
+    private filter;
+    constructor(service: Service<TData>, statistics: any, filter: object);
+    /**
+     * Gets the next page of available data from the server.
+     * @param filter
+     */
+    next(filter?: object): Promise<IResultList<TData>>;
+    /**
+     * Gets the previous page of available data from server.
+     * @param filter
+     */
+    prev(filter?: object): Promise<IResultList<TData>>;
+    /**
+     * Method used by next(), prev() and goto() to call the service.list method.
+     * It is public so it can be overriden in special cases (like children objects
+     * in inventory).
+     * @param filter
+     */
+    list(filter?: object): Promise<IResultList<TData>>;
+    /**
+     * Goes to the page that you define as page parameter.
+     * @param page
+     * @param filter
+     */
+    goto(page: number, filter?: object): Promise<IResultList<TData>>;
+    private getFilter;
+}
+//# sourceMappingURL=Paging.d.ts.map

package/lib/cjs/src/core/QueriesUtil.d.ts

@@ -0,0 +1,95 @@
+export declare class QueriesUtil {
+    protected operatorFns: {
+        __not: (operand: any) => string;
+        __and: (operand: any) => string;
+        __or: (operand: any) => string;
+        __eq: (operand: any, contextKey: any) => string;
+        __gt: (operand: any, contextKey: any) => string;
+        __ge: (operand: any, contextKey: any) => string;
+        __lt: (operand: any, contextKey: any) => string;
+        __le: (operand: any, contextKey: any) => string;
+        __in: (operand: any, contextKey: any) => any;
+        __bygroupid: (operand: any) => string;
+        __has: (operand: any) => string;
+        __useFilterQueryString: (queryString: string) => string;
+    };
+    /**
+     * Builds query string from provided query object.
+     *
+     * @param query Object containing filters and sort order for querying managed objects. Supported filters are:
+     * - **__and** - Specifies conditions, e.g. `{__and: [{__has: 'c8y_IsDevice'}, {'count': {__gt: 0}}]}`.
+     * - **__or** - Specifies alternative conditions, e.g. `{__or: [{__bygroupid: 10300}, {__bygroupid: 10400}]}`.
+     * - **__eq** - Specified fragment must be equal to given value, e.g. `{'status': 'AVAILABLE'}` (no nested object required).
+     * - **__lt** - Specified fragment must be less then given value, e.g. `{'count': {__lt: 10}}`.
+     * - **__gt** - Specified fragment must be greater then given value, e.g. `{'count': {__gt: 0}}`.
+     * - **__in** - Specified fragment must be equal to one of values in the list, e.g. `{'status': {__in: ['AVAILABLE', 'UNAVAILABLE']}}`.
+     * - **__not** - Negates condition, e.g. `{__not: {'status': 'AVAILABLE'}}`.
+     * - **__bygroupid** - True if filtered managed object is assigned to given group, e.g. `{__bygroupid: 10300}`.
+     * - **__has** - Specified fragment must have a value defined, e.g. `{__has: 'c8y_IsDevice'}`.
+     * - **__useFilterQueryString** - Gets rid of the `$filter=()… $orderby=…` parts of a query and keeps only what's between the most
+     *                                exterior parentheses of the $filter.
+     *                                EXAMPLE: takes a query of the form
+     *                                `$filter=(name eq 'RaspPi*') $orderby=name asc`
+     *                                and turns it into
+     *                                `name eq 'RaspPi*'`
+     *                                This is necessary for searching for smart groups, which are identified by their own query
+     *                                that needs to be passed through.
+     *
+     * Note: if you want to specify the order, you need to wrap your filters within `__filter` property and then add `__orderby` with the array of field paths and sort directions (1 for ascending, -1 for descending), for example:
+     * - `{ __filter: { ... }, __orderby: [{ 'creationTime': -1 }, { 'name': 1 }] }`
+     *
+     * @returns {string} Returns a query string ready to be sent in request params to backend.
+     *
+     * **Example**
+     * ```typescript
+     *   const query = {
+     *     __filter: {
+     *       'name': 'My Device*',
+     *       'c8y_Availability.status': {
+     *         __in: ['AVAILABLE', 'UNAVAILABLE']
+     *       },
+     *       'creationTime': {
+     *         __lt: '2015-11-30T13:28:123Z'
+     *       },
+     *       'c8y_ActiveAlarmsStatus.critical': {
+     *         __gt: 0
+     *       },
+     *       __or: [
+     *         {__not: {__has: 'c8y_ActiveAlarmsStatus.major'}},
+     *         {
+     *           __or: [
+     *             {__bygroupid: 10300},
+     *             {__bygroupid: 10400}
+     *           ]
+     *         }
+     *       ]
+     *     },
+     *     __orderby: [
+     *       {'name': 1},
+     *       {'creationTime': -1},
+     *       {'c8y_ActiveAlarmsStatus.critical': -1}
+     *     ]
+     *   };
+     *
+     *   const params = {
+     *     query: queriesUtil.buildQuery(query)
+     *   };
+     * ```
+     */
+    buildQuery(query: any): string;
+    buildQueryFilter(queryFilter: any, _queryKey?: any, _glueType?: any): string;
+    buildQueryOrderby(queryOrderbys: any): string;
+    addAndFilter(query: any, filter: any): any;
+    addOrFilter(query: any, filter: any): any;
+    addFilter(query: any, filter: any, operator: 'and' | 'or'): any;
+    prependOrderbys(query: any, orderbys: any): any;
+    appendOrderbys(query: any, orderbys: any): any;
+    addOrderbys(query: any, orderbys: any, how: 'prepend' | 'append'): any;
+    extractAndMergeOrderBys(queries: string[]): string;
+    protected glue(stmts: any[], type: string): any;
+    protected quoteString(s: any): any;
+    protected skipEmptyObjects(objs: any[]): any[];
+    protected isEmptyObject(obj: object): boolean;
+    private escapeSingleQuote;
+}
+//# sourceMappingURL=QueriesUtil.d.ts.map

package/lib/cjs/src/core/Service.d.ts

@@ -0,0 +1,45 @@
+import { IFetchClient } from './IFetchClient';
+import { IFetchOptions } from './IFetchOptions';
+import { IFetchResponse } from './IFetchResponse';
+import { IIdentified } from './IIdentified';
+import { IResult } from './IResult';
+import { IResultList } from './IResultList';
+import { Paging } from './Paging';
+import { Realtime } from '../realtime/index';
+export declare abstract class Service<TData extends IIdentified> {
+    protected client: IFetchClient;
+    protected realtime?: Realtime;
+    protected propertyName: string;
+    protected abstract baseUrl: string;
+    protected abstract listUrl: string;
+    protected channel: string;
+    private cache;
+    constructor(client: IFetchClient, realtime?: Realtime);
+    list(filter?: object): Promise<IResultList<TData>>;
+    protected detail(entityOrId: string | number | IIdentified, filter?: object): Promise<IResult<TData>>;
+    protected create(entity: Partial<TData>): Promise<IResult<TData>>;
+    protected update(entity: Partial<TData>): Promise<IResult<TData>>;
+    protected delete(entityOrId: string | number | IIdentified, params?: any): Promise<IResult<null>>;
+    protected onBeforeCreate(obj: Partial<TData>): Partial<TData>;
+    protected onBeforeUpdate(objWithId: Partial<TData>): Partial<TData>;
+    protected changeFetchOptions(options: any, _url?: string): any;
+    protected getUrl(url?: string): string;
+    protected getEntityId(entityOrId: string | number | IIdentified): string;
+    protected getDetailUrl(entityOrId: string | number | IIdentified): string;
+    protected fetch(url: string, init?: IFetchOptions): Promise<IFetchResponse>;
+    /**
+     * Checks the response for errors and throws exceptions, otherwise returns the response as is.
+     *
+     * @param response The response from server.
+     *
+     * @returns If no errors are detected, it returns the same response.
+     *
+     * @throws If an error is detected, it throws `{ res, data }`, where `data` contains error details from server.
+     */
+    protected handleErrorStatusCodes(response: IFetchResponse): Promise<IFetchResponse>;
+    protected mimeType(type: string): string;
+    protected getIdString(reference: number | string | IIdentified): string;
+    protected getPaging(json: any, filter: object): Paging<TData>;
+    protected getCurrentPageFromLink(link?: string): number;
+}
+//# sourceMappingURL=Service.d.ts.map

package/lib/cjs/src/core/Severity.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Severity can be one of the following states.
+ * It is used in [[AlarmService]] for example.
+ */
+export declare enum Severity {
+    CRITICAL,
+    MAJOR,
+    MINOR,
+    WARNING
+}
+//# sourceMappingURL=Severity.d.ts.map

package/lib/cjs/src/core/index.d.ts

@@ -0,0 +1,23 @@
+export * from './Service';
+export * from './FetchClient';
+export * from './IAuthentication';
+export * from './BasicAuth';
+export * from './BearerAuth';
+export * from './CookieAuth';
+export * from './MicroserviceClientRequestAuth';
+export * from './NodeJSCookieAuth';
+export * from './IIdentified';
+export * from './INamed';
+export * from './IResult';
+export * from './IResultList';
+export * from './IFetchOptions';
+export * from './IFetchResponse';
+export * from './IFetchClient';
+export * from './IMicroserviceSubscriptions';
+export * from './Paging';
+export * from './ISource';
+export * from './Severity';
+export * from './ICustomProperties';
+export * from './ICustomPropertiesMap';
+export * from './QueriesUtil';
+//# sourceMappingURL=index.d.ts.map