@c8y/client 1018.487.7 → 1018.497.2

package/lib/cjs/src/device-registration/DeviceRegistrationBulkService.d.ts

@@ -0,0 +1,41 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Stream } from 'stream';
+import { IFetchClient, IResult } from '../core';
+import { IDeviceRegistrationBulkResult } from './IDeviceRegistrationBulkResult';
+/**
+ * This class allows for bulk registering devices.
+ */
+export declare class DeviceRegistrationBulkService {
+    protected client: IFetchClient;
+    /**
+     * Instantiate class and assign client
+     * @param {IFetchClient} client
+     */
+    constructor(client: IFetchClient);
+    /**
+     * A new device registration as bulk.
+     *
+     * @param {Stream | Buffer} csv
+     *
+     * @returns Response wrapped in [[IResult]]
+     *
+     * **Example**
+     * ```typescript
+     *
+     *  const csvString = `
+     *  ID,CREDENTIALS,TENANT,TYPE,NAME,ICCID,IDTYPE,PATH,SHELL
+     *  e2eDeviceRegistrationId,e2epassword123!,e2edocker,c8y_e2eDevice,e2eDevice,123456789,89456,e2eDeviceGroup,1
+     *  900001,e2epassword123!,e2edocker,c8y_e2eDevice1,e2eDevice1,123456789,89456,e2eDeviceGroup,1
+     *  900002,e2epassword123!,e2edocker,c8y_e2eDevice2,e2eDevice2,123456789,89456,e2eDeviceGroup,1`.trim();
+     *
+     *  const csvBuffer = Buffer.from(csvString):
+     *
+     *  (async () => {
+     *    const {data, res} = await deviceRegistrationBulkService.create(csvBuffer);
+     *  })();
+     * ```
+     */
+    create(inputFile: Stream | Buffer | File | Blob): Promise<IResult<IDeviceRegistrationBulkResult>>;
+}
+//# sourceMappingURL=DeviceRegistrationBulkService.d.ts.map

package/lib/cjs/src/device-registration/DeviceRegistrationSecurityMode.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Device registration can have one of the following security modes.
+ */
+export declare enum DeviceRegistrationSecurityMode {
+    REQUIRED = "REQUIRED",
+    OPTIONAL = "OPTIONAL",
+    IGNORED = "IGNORED"
+}
+//# sourceMappingURL=DeviceRegistrationSecurityMode.d.ts.map

package/lib/cjs/src/device-registration/DeviceRegistrationService.d.ts

@@ -0,0 +1,199 @@
+import { IIdentified, Service, IResult, IResultList } from '../core';
+import { IDeviceRegistration, IDeviceRegistrationAccept, IDeviceRegistrationCreate, IDeviceRegistrationLimit } from './IDeviceRegistration';
+import { IDeviceCredentials } from './IDeviceCredentials';
+/**
+ * Interface to use as options parameter
+ * to bootstrap a new device.
+ */
+export interface IDeviceBootstrapOptions {
+    /**
+     * If already logged in it is accessible via
+     * client.auth.getFetchOptions, see [[BasicAuth.getFetchOptions]]
+     *
+     * **Example**
+     * ``` typescript
+     *
+     * // tenant/username:password
+     * const basicAuthToken = 'Basic dGVuYW50L3VzZXJuYW1lOnBhc3N3b3Jk';
+     * ```
+     */
+    basicAuthToken?: string;
+    /**
+     * Object to define username and password
+     * as string.
+     *
+     * **Example**
+     * ``` typescript
+     *
+     *    const basicAuth = {
+     *      user: 'username',
+     *      pass: 'password'
+     *    }
+     * ```
+     */
+    basicAuth?: {
+        user: string;
+        pass: string;
+    };
+}
+/**
+ * This class allows registration of a new device.
+ */
+export declare class DeviceRegistrationService extends Service<IDeviceRegistration> {
+    protected baseUrl: string;
+    protected listUrl: string;
+    protected propertyName: string;
+    /**
+     * Gets the details of device registration.
+     *
+     * @param {string|number|IIdentified} entityOrId Entity or Id of the entity.
+     *
+     * @returns Response wrapped in [[IResult]]
+     *
+     * **Example**
+     * ```typescript
+     *
+     *    const entityId: number = 1;
+     *
+     *    (async () => {
+     *      const {data, res} = await deviceRegistrationService.detail(entityId);
+     *    })();
+     * ```
+     */
+    detail(entityOrId: string | number | IIdentified): Promise<IResult<IDeviceRegistration>>;
+    /**
+     * Creates a new device registration.
+     *
+     * @param {IDeviceRegistrationCreate} entity Device registration object with mandantory fragments.
+     *
+     * @returns Response wrapped in [[IResult]]
+     *
+     * **Example**
+     * ```typescript
+     *
+     *    const mandantoryObject: IDeviceRegistrationCreate = {
+     *      id: 1,
+     *    };
+     *
+     *    (async () => {
+     *      const {data, res} = await deviceRegistrationService.create(mandantoryObject);
+     *    })();
+     * ```
+     */
+    create(entity: IDeviceRegistrationCreate): Promise<IResult<IDeviceRegistration>>;
+    /**
+     * Gets the list of device registrations by parameters.
+     *
+     * @returns Response wrapped in [[IResultList]]
+     *
+     * @param {object} filter Object containing filters for querying registrations.
+     *
+     * **Example**
+     * ```typescript
+     *
+     *   const filter: object = {
+     *     pageSize: 100,
+     *     withTotalPages: true
+     *   };
+     *
+     *   (async () => {
+     *     const {data, res, paging} = await deviceRegistrationService.list(filter);
+     *   })();
+     * ```
+     */
+    list(filter?: object): Promise<IResultList<IDeviceRegistration>>;
+    /**
+     * Removes an registration with given id.
+     *
+     * @returns Response wrapped in [[IResult]]
+     *
+     * @param {string | number | IIdentified} entityOrId entity or id of the registration.
+     *
+     * **Example**
+     * ```typescript
+     *
+     *   const id = 'abc';
+     *
+     *   (async () => {
+     *     const {data, res} = await deviceRegistrationService.delete(id);
+     *     // data will be null
+     *   })();
+     * ```
+     */
+    delete(entityOrId: string | number | IIdentified): Promise<IResult<null>>;
+    /**
+     * Accepts the device registration for given id.
+     *
+     * @returns Response wrapped in [[IResult]]
+     *
+     * @param {string | number | IIdentified} entityOrId entity or id of registration.
+     *
+     * **Example**
+     * ```typescript
+     *
+     *   const id = 'abc';
+     *
+     *   (async () => {
+     *     const {data, res} = await deviceRegistrationService.accept(id);
+     *   })();
+     * ```
+     */
+    accept(entityOrId: string | number | IIdentified): Promise<IResult<IDeviceRegistration>>;
+    /**
+     * Accepts the device registration for all registrations in pending acceptance.
+     *
+     * @returns Response wrapped in [[IResultList]]
+     *
+     * **Example**
+     * ```typescript
+     *
+     *   (async () => {
+     *     const {data, res} = await deviceRegistrationService.acceptAll();
+     *   })();
+     * ```
+     */
+    acceptAll(): Promise<IResultList<IDeviceRegistrationAccept>>;
+    /**
+     * Gets limitation information for registering devices to the platform
+     *
+     * @returns Response wrapped in [[IResult]]
+     *
+     * **Example**
+     * ```typescript
+     *
+     *   (async () => {
+     *     const {data, res} = await deviceRegistrationService.limit();
+     *   })();
+     * ```
+     */
+    limit(): Promise<IResult<IDeviceRegistrationLimit>>;
+    /**
+     * Bootstraps the device with given id.
+     *
+     * @param entityOrId entity or id of registration.
+     * @param options for details see [[IDeviceBootstrapOptions]]
+     *
+     * **Example**
+     * ```typescript
+     *
+     *   const id: 'abc';
+     *   const options: IDeviceBootstrapOptions = {
+     *     basicAuthToken: 'Basic dGVuYW50L3VzZXJuYW1lOnBhc3N3b3Jk',
+     *     basicAuth: {
+     *       user: 'username',
+     *       pass: 'password'
+     *     }
+     *   };
+     *
+     *   (async () => {
+     *     const {data, res} = await deviceRegistrationService.bootstrap(id, options);
+     *   })();
+     * ```
+     */
+    bootstrap(entityOrId: string | number | IIdentified, options: IDeviceBootstrapOptions): Promise<IResult<IDeviceCredentials>>;
+    protected onBeforeCreate(entity: IDeviceRegistrationCreate): IDeviceRegistrationCreate;
+    protected onBeforeUpdate(entity: IDeviceRegistrationCreate): IDeviceRegistrationCreate;
+    protected getDetailUrl(entityOrId: string | number | IIdentified): string;
+    private getSecurityToken;
+}
+//# sourceMappingURL=DeviceRegistrationService.d.ts.map

package/lib/cjs/src/device-registration/DeviceRegistrationStatus.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Device registration can have one of the following states.
+ */
+export declare enum DeviceRegistrationStatus {
+    WAITING_FOR_CONNECTION,
+    PENDING_ACCEPTANCE,
+    ACCEPTED,
+    BLOCKED
+}
+//# sourceMappingURL=DeviceRegistrationStatus.d.ts.map

package/lib/cjs/src/device-registration/IDeviceCredentials.d.ts

@@ -0,0 +1,23 @@
+export interface IDeviceCredentials {
+    /**
+     * Device identifier, e.g. IMEI
+     */
+    id: string;
+    /**
+     * New password
+     */
+    password: string;
+    /**
+     * Link to this resource
+     */
+    self: string;
+    /**
+     * Tenant id for authentication
+     */
+    tenantId: string;
+    /**
+     * New username
+     */
+    username: string;
+}
+//# sourceMappingURL=IDeviceCredentials.d.ts.map

package/lib/cjs/src/device-registration/IDeviceRegistration.d.ts

@@ -0,0 +1,76 @@
+import { DeviceRegistrationStatus } from './';
+export interface IDeviceRegistrationCreate {
+    /**
+     * Object for custom fragments
+     */
+    customProperties?: {
+        [key: string]: any;
+    };
+    /**
+     * Identifies the owner of the object
+     */
+    owner?: string;
+    /**
+     * Shows the server-side creation time of the object
+     */
+    creationTime?: string;
+    /**
+     * Identifies the target group
+     */
+    groupId?: string;
+    /**
+     * Unique identifier
+     */
+    id: string;
+    /**
+     * Identifies the type of request, e.g.: c8y_DataBroker. For device requests value is normally skipped.
+     */
+    type?: string;
+}
+export interface IDeviceRegistration extends IDeviceRegistrationCreate {
+    /**
+     * Link to this resource
+     */
+    self: string;
+    /**
+     * Possible state of device registration
+     */
+    status: DeviceRegistrationStatus;
+    /**
+     * Identifies the tenant
+     */
+    tenantId: string;
+    /**
+     * Security token for a device may be required to register successfully
+     */
+    securityToken?: string;
+}
+export interface IDeviceRegistrationAccept {
+    /**
+     * Unique identifier of accepted device registration
+     */
+    id: string;
+    /**
+     * Success state of device registration
+     */
+    successful: boolean;
+    /**
+     * Text to describe an error that occurred while registering the device
+     */
+    error?: string;
+}
+export interface IDeviceRegistrationLimit {
+    /**
+     * Indicates if the limit is reached
+     */
+    isReached: boolean;
+    /**
+     * Shows the current limit
+     */
+    limit?: number;
+    /**
+     * Shows the current registered device count
+     */
+    deviceCount?: number;
+}
+//# sourceMappingURL=IDeviceRegistration.d.ts.map

package/lib/cjs/src/device-registration/IDeviceRegistrationBulkResult.d.ts

@@ -0,0 +1,27 @@
+export interface IDeviceRegistrationBulkResult {
+    /**
+     * Result list of updated credentials
+     */
+    credentialUpdatedList: any[];
+    /**
+     * Failed creations as list
+     */
+    failedCreationList: any[];
+    /**
+     * Count of all results
+     */
+    numberOfAll: number;
+    /**
+     * Count of newly created
+     */
+    numberOfCreated: number;
+    /**
+     * Count of failed
+     */
+    numberOfFailed: number;
+    /**
+     * Count of successful
+     */
+    numberOfSuccessful: number;
+}
+//# sourceMappingURL=IDeviceRegistrationBulkResult.d.ts.map

package/lib/cjs/src/device-registration/index.d.ts

@@ -0,0 +1,8 @@
+export * from './DeviceRegistrationService';
+export * from './DeviceRegistrationBulkService';
+export * from './IDeviceRegistration';
+export * from './IDeviceRegistrationBulkResult';
+export * from './IDeviceCredentials';
+export * from './DeviceRegistrationStatus';
+export * from './DeviceRegistrationSecurityMode';
+//# sourceMappingURL=index.d.ts.map

package/lib/cjs/src/event/EventBinaryService.d.ts

@@ -0,0 +1,64 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Stream } from 'stream';
+import { Service, IResult, IFetchResponse } from '../core';
+import { IEvent } from './IEvent';
+import { IEventBinary } from './IEventBinary';
+export declare class EventBinaryService extends Service<IEventBinary> {
+    protected baseUrl: string;
+    protected listUrl: string;
+    /**
+     * Uploads an event binary.
+     * @returns Response wrapped in [[IResult]]
+     *
+     * @param {Stream | Buffer | File | Blob} file file to upload.
+     * @param {string | number | IEvent} eventOrId Event or Id of the Event.
+     *
+     * **Example**
+     * ```typescript
+     *
+     *   const file = Buffer.from('aaa');
+     *   const eventId: string | number = 123;
+     *
+     *    (async () => {
+     *      const {data, res} = await eventBinaryService.upload(file, eventId);
+     *   })();
+     * ```
+     */
+    upload(file: Stream | Buffer | File | Blob, entityOrId: string | number | IEvent): Promise<IResult<IEventBinary>>;
+    /**
+     * Downloads the binary for a given event.
+     * @returns Response wrapped in [[IFetchResponse]]
+     *
+     * @param {string | number | IEvent} eventOrId Event or Id of the Event.
+     *
+     * **Example**
+     * ```typescript
+     *
+     *   const eventId: string | number = 123;
+     *
+     *    (async () => {
+     *      const res = await eventBinaryService.download(eventId);
+     *   })();
+     */
+    download(entityOrId: string | number | IEvent): Promise<IFetchResponse>;
+    /**
+     * Removes the binary for a given event.
+     * @returns Response wrapped in [[IResult]]
+     *
+     * @param {string | number | IEvent} eventOrId Event or Id of the Event.
+     *
+     * **Example**
+     * ```typescript
+     *
+     *   const eventId: string | number = 123;
+     *
+     *    (async () => {
+     *      const {data, res} = await eventBinaryService.delete(eventId);
+     *   })();
+     * ```
+     */
+    delete(entityOrId: string | number | IEvent): Promise<IResult<null>>;
+    protected getDetailUrl(entityOrId: string | number | IEvent): string;
+}
+//# sourceMappingURL=EventBinaryService.d.ts.map

package/lib/cjs/src/event/EventService.d.ts

@@ -0,0 +1,114 @@
+import { IIdentified, Service, IResult, IResultList } from '../core';
+import { IEvent } from './IEvent';
+/**
+ * This class allows managing for events.
+ */
+export declare class EventService extends Service<IEvent> {
+    protected baseUrl: string;
+    protected listUrl: string;
+    protected propertyName: string;
+    protected channel: string;
+    /**
+     * Gets the details of a specific event.
+     *
+     * @param {string|number|IIdentified} entityOrId Entity or Id of the entity.
+     *
+     * @returns Response wrapped in [[IResult]]
+     *
+     * **Example**
+     * ```typescript
+     *
+     *    const eventId: number = 1;
+     *
+     *    (async () => {
+     *      const {data, res} = await eventService.detail(eventId);
+     *   })();
+     * ```
+     */
+    detail(entityOrId: string | number | IIdentified): Promise<IResult<IEvent>>;
+    /**
+     * Creates a new event.
+     *
+     * @param {IEvent} entity Event object with mandantory fragments.
+     *
+     * @returns Response wrapped in [[IResult]]
+     *
+     * **Example**
+     * ```typescript
+     *
+     *  const mandantoryObject: IEvent = {
+     *    source: device,
+     *    text: 'I am an Event!',
+     *    time: '2018-05-02T10:08:00Z',
+     *    type: 'device-type-here',
+     *  };
+     *
+     *  (async () => {
+     *    const {data, res} = await eventService.create(mandantoryObject);
+     *  })();
+     * ```
+     */
+    create(entity: IEvent): Promise<IResult<IEvent>>;
+    /**
+     * Updates event data.
+     *
+     * @param {Partial<IEvent>} entity Event is partially updatable.
+     *
+     * @returns Response wrapped in [[IResult]]
+     *
+     * **Example**
+     * ```typescript
+     *
+     *  const partialUpdateObject: Partial<IEvent> = {
+     *    source: device,
+     *    text: 'Changed Event!'
+     *  };
+     *
+     *  (async () => {
+     *    const {data, res} = await eventService.update(partialUpdateObject);
+     *  })();
+     * ```
+     */
+    update(entity: Partial<IEvent>): Promise<IResult<IEvent>>;
+    /**
+     * Gets the list of events filtered by parameters.
+     *
+     * @returns Response wrapped in [[IResultList]]
+     *
+     * @param {object} filter Object containing filters for querying events.
+     *
+     * **Example**
+     * ```typescript
+     *
+     *  const filter: object = {
+     *     pageSize: 100,
+     *     withTotalPages: true
+     *   };
+     *
+     *   (async () => {
+     *     const {data, res, paging} = await eventService.list(filter);
+     *   })();
+     * ```
+     */
+    list(filter?: object): Promise<IResultList<IEvent>>;
+    /**
+     * Removes an event with given id.
+     *
+     * @returns Response wrapped in [[IResult]]
+     *
+     * @param {string | number | IIdentified} entityOrId entity or id of the event.
+     *
+     * **Example**
+     * ```typescript
+     *
+     *  const eventId: number = 1;
+     *
+     *   (async () => {
+     *     const {data, res} = await eventService.delete(eventId);
+     *     // data will be null
+     *   })();
+     * ```
+     */
+    delete(entityOrId: string | number | IIdentified): Promise<IResult<null>>;
+}
+//# sourceMappingURL=EventService.d.ts.map

package/lib/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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