@c8y/client 1018.486.5 → 1018.496.6

package/lib/esm2015/src/event/IEvent.d.ts

@@ -0,0 +1,39 @@
+import { ISource } from '../core';
+/**
+ * This interface holds all fragments that describe an event object
+ */
+export interface IEvent {
+    /**
+     * The ManagedObject that the event originated from, see [[ISource]]
+     */
+    source: ISource;
+    /**
+     * Identifies the type of this event
+     */
+    type: string;
+    /**
+     * Time of the event
+     */
+    time: string;
+    /**
+     * Text description of the event
+     */
+    text: string;
+    /**
+     * Uniquely identifies an event
+     */
+    id?: string | number;
+    /**
+     * Link to this resource
+     */
+    self?: string;
+    /**
+     * Time when event was created in the database
+     */
+    creationTime?: string;
+    /**
+     * Custom fragments
+     */
+    [key: string]: any;
+}
+//# sourceMappingURL=IEvent.d.ts.map

package/lib/esm2015/src/event/IEventBinary.d.ts

@@ -0,0 +1,26 @@
+/**
+ * This interface specifies all fragments that describe an event binary.
+ */
+export interface IEventBinary {
+    /**
+     * Binary name
+     */
+    name: string;
+    /**
+     * Link to this resource
+     */
+    self?: string;
+    /**
+     * The Event that the binary belongs to
+     */
+    source?: string;
+    /**
+     * Binary file length
+     */
+    length?: number;
+    /**
+     * MIME type of the binary file
+     */
+    type?: string;
+}
+//# sourceMappingURL=IEventBinary.d.ts.map

package/lib/esm2015/src/event/index.d.ts

@@ -0,0 +1,5 @@
+export * from './EventService';
+export * from './EventBinaryService';
+export * from './IEvent';
+export * from './IEventBinary';
+//# sourceMappingURL=index.d.ts.map

package/lib/esm2015/src/gettext.d.ts

@@ -0,0 +1,3 @@
+/** Identity function used for marking strings for translation */
+export declare const gettext: (t: any) => any;
+//# sourceMappingURL=gettext.d.ts.map

package/lib/esm2015/src/identity/IExternalIdentity.d.ts

@@ -0,0 +1,24 @@
+import { IIdentified } from '../core';
+/**
+ * This interface holds all fragments that can be used to define
+ * an identity object.
+ */
+export interface IExternalIdentity {
+    /**
+     * The identifier used in the external system that Cumulocity interfaces with
+     */
+    externalId: string;
+    /**
+     * The type of the external identifier as string, e.g., "com_cumulocity_model_idtype_SerialNumber"
+     */
+    type: string;
+    /**
+     * The ManagedObject linked to the external ID
+     */
+    managedObject?: IIdentified;
+    /**
+     * Link to this resource
+     */
+    self?: string;
+}
+//# sourceMappingURL=IExternalIdentity.d.ts.map

package/lib/esm2015/src/identity/IdentityService.d.ts

@@ -0,0 +1,102 @@
+import { IResult, IResultList, IFetchClient } from '../core';
+import { IExternalIdentity } from './IExternalIdentity';
+/**
+ * This class allwos for managing external identifiers.
+ */
+export declare class IdentityService {
+    private baseUrl;
+    private propertyName;
+    private client;
+    constructor(client: IFetchClient);
+    /**
+     * Gets the list of identities filtered by parameters.
+     *
+     * @returns Response wrapped in [[IResultList]]
+     *
+     * @param {object} filter Object containing filters for querying identity.
+     *
+     * **Example**
+     * ```typescript
+     *
+     *  const filter: object = {
+     *     pageSize: 100,
+     *     withTotalPages: true
+     *   };
+     *
+     *   (async () => {
+     *     const {data, res, paging} = await identityService.list(filter);
+     *   })();
+     * ```
+     */
+    list(managedObjectId: string): Promise<IResultList<IExternalIdentity>>;
+    /**
+     * Creates a new identity.
+     *
+     * @param {IExternalIdentity} identity Identity object with mandantory fragments.
+     *
+     * @returns Response wrapped in [[IResult]]
+     *
+     * **Example**
+     * ```typescript
+     *   const linkedManagedObjectId = '123';
+     *   const identity: IExternalIdentity = {
+     *      type: 'type',
+     *      externalId: '1',
+     *      managedObject: {
+     *        id: linkedManagedObjectId
+     *      }
+     *    };
+     *
+     *    (async () => {
+     *      const {data, res} = await identityService.create(identity);
+     *   })();
+     * ```
+     */
+    create(identity: IExternalIdentity): Promise<IResult<IExternalIdentity>>;
+    /**
+     * Gets the details of an identity.
+     *
+     * @param {IExternalIdentity} identity Identity object with mandantory fragments.
+     *
+     * @returns Response wrapped in [[IResult]]
+     *
+     * **Example**
+     * ```typescript
+     *
+     *    const identity: IExternalIdentity = {
+     *      type: 'type',
+     *      externalId: '1'
+     *    };
+     *
+     *    (async () => {
+     *      const {data, res} = await identityService.detail(identity);
+     *   })();
+     * ```
+     */
+    detail(identity: IExternalIdentity): Promise<IResult<IExternalIdentity>>;
+    /**
+     * Removes an identity with given id.
+     *
+     * @returns Response wrapped in [[IResult]]
+     *
+     * @param {IExternalIdentity} identity Identity object with mandantory fragments.
+     *
+     * **Example**
+     * ```typescript
+     *
+     *   const identity: IExternalIdentity = {
+     *      type: 'type',
+     *      externalId: '1'
+     *    };
+     *
+     *    (async () => {
+     *      const {data, res} = await identityService.delete(identity);
+     *   })();
+     * ```
+     */
+    delete(identity: IExternalIdentity): Promise<IResult<IExternalIdentity>>;
+    private fetch;
+    private getExternalIdsOfGlobalIdUrl;
+    private getExternalIdUrl;
+}
+//# sourceMappingURL=IdentityService.d.ts.map

package/lib/esm2015/src/identity/index.d.ts

@@ -0,0 +1,3 @@
+export * from './IExternalIdentity';
+export * from './IdentityService';
+//# sourceMappingURL=index.d.ts.map

package/lib/esm2015/src/inventory/IManagedObject.d.ts

@@ -0,0 +1,88 @@
+import { ISource } from '../core';
+export interface IManagedObjectReference {
+    /**
+     * ManagedObject data itself with mandantory fragments of [[ISource]] at least
+     */
+    managedObject: ISource;
+    /**
+     * Link to this resource
+     */
+    self?: string;
+}
+export interface IManagedObjectReferences {
+    /**
+     * References array of type [[IManagedObjectReference]]
+     */
+    references: IManagedObjectReference[];
+    /**
+     * Link to this resource
+     */
+    self?: string;
+}
+export interface IManagedObject {
+    /**
+     * Time when ManagedObject was created in the database
+     */
+    creationTime: string;
+    /**
+     * Unique identifier of the object, automatically allocated when the object is created
+     */
+    id: string;
+    /**
+     * The time when the object was last updated
+     */
+    lastUpdated: string;
+    /**
+     * The owner of the managed object
+     */
+    owner: string;
+    /**
+     * Link to this resource
+     */
+    self: string;
+    /**
+     * A collection of references to additional parents objects
+     */
+    additionParents: IManagedObjectReferences;
+    /**
+     * A collection of references to device parent objects
+     */
+    assetParents: IManagedObjectReferences;
+    /**
+     * A collection of references to child addition objects
+     */
+    childAdditions: IManagedObjectReferences;
+    /**
+     * A collection of references to child assets
+     */
+    childAssets: IManagedObjectReferences;
+    /**
+     * A collection of references to child devices
+     */
+    childDevices: IManagedObjectReferences;
+    /**
+     * A collection of references to device parent objects
+     */
+    deviceParents: IManagedObjectReferences;
+    /**
+     * Custom fragments
+     */
+    [key: string]: any;
+}
+export interface IManagedObjectBinary extends Partial<IManagedObject> {
+    c8y_IsBinary: object;
+    length: number;
+    name: string;
+    type: string;
+    contentType: string;
+    _attachments?: {
+        [key: string]: {
+            stub: boolean;
+            length: number;
+            digest: string;
+            revpos: number;
+            content_type: string;
+        };
+    };
+}
+//# sourceMappingURL=IManagedObject.d.ts.map

package/lib/esm2015/src/inventory/InventoryBinaryService.d.ts

@@ -0,0 +1,45 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Stream } from 'stream';
+import { Service, IResult, IFetchResponse, IFetchOptions } from '../core';
+import { IdReference } from './InventoryService';
+import { IManagedObject, IManagedObjectBinary } from './IManagedObject';
+export declare class InventoryBinaryService extends Service<IManagedObjectBinary> {
+    protected baseUrl: string;
+    protected listUrl: string;
+    protected propertyName: string;
+    /**
+     * Uploads a file and creates a managed object with its metadata.
+     * @param file A file to be uploaded.
+     * @param managedObject An object containing metadata about the file.
+     * Note that you can specify `fileType` and `fileName` in case `file` does not define them
+     * but these two properties will be removed from `managedObject` before saving.
+     */
+    create(file: Stream | Buffer | File | Blob, managedObject?: Partial<IManagedObject>): Promise<IResult<IManagedObjectBinary>>;
+    list(filter?: object): Promise<import("../core").IResultList<IManagedObjectBinary>>;
+    delete(managedObjectOrId: IdReference): Promise<IResult<null>>;
+    download(managedObjectOrId: IdReference, init?: IFetchOptions): Promise<IFetchResponse>;
+    /**
+     * Uploads a file and creates a managed object with its metadata. What's more, it invokes an upload progress callback.
+     * @param file A file to be uploaded.
+     * @param managedObject An object containing metadata about the file.
+     * @param onProgress Event handler for progress update, invoked while the browser is uploading the file.
+     */
+    createWithProgress(file: Stream | Buffer | File | Blob, onProgress: EventListener, managedObject?: Partial<IManagedObject>): XMLHttpRequest;
+    getXMLHttpResponse(xhr: any): Promise<IResult<IManagedObjectBinary>>;
+    /**
+     * Gets binary managed object's id from its download or self URL.
+     *
+     * @param {string} url URL string.
+     *
+     * @returns {number} Binary managed object's id.
+     *
+     * **Example**
+     * ```typescript
+     *
+     *   const id = InventoryBinaryService.getIdFromUrl('http://mytenant.cumulocity.com/inventory/binaries/12345');
+     * ```
+     */
+    getIdFromUrl(url: string): string;
+}
+//# sourceMappingURL=InventoryBinaryService.d.ts.map