@c8y/client 1018.486.5 → 1018.496.6

package/lib/cjs/index.d.ts

@@ -0,0 +1,2 @@
+export * from './src/public_api';
+//# sourceMappingURL=index.d.ts.map

package/lib/cjs/src/Client.d.ts

@@ -0,0 +1,190 @@
+import { IAuthentication, ICredentials, IFetchResponse } from './core';
+import { Realtime } from './realtime';
+import { FetchClient, AlarmService, ApplicationService, AuditService, DeviceRegistrationBulkService, DeviceRegistrationService, EventService, InventoryBinaryService, InventoryRoleService, InventoryService, MeasurementService, OperationBulkService, OperationService, SystemOptionsService, TenantOptionsService, TenantSecurityOptionsService, TenantLoginOptionsService, TenantService, UserGroupService, UserRoleService, UserService, IdentityService, SmartGroupsService, SmartRulesService } from './services';
+export interface IBootstrapOptions {
+    deviceId: string;
+    basicAuthToken: string;
+    timeout?: number;
+    expire?: number;
+    baseUrl?: string;
+}
+export declare class Client {
+    /**
+     * Authenticates the given user. Determines the tenant by itself via a call to tenant/currentTenant.
+     *
+     * **Example**
+     * ```typescript
+     *
+     * let client: Client;
+     * (async () => {
+     *  client = await Client.authenticate({
+     *    user: 'testuser',
+     *    password: 'password1337!'
+     *  }, 'https://acme.cumulocity.com');
+     *
+     *  //you have access to the client api now
+     *  const { data, paging, res }); =  await client.inventory.list({ pageSize: 100 });
+     * })();
+     * ```
+     */
+    static authenticate(credentials: ICredentials, baseUrl?: string): Promise<Client>;
+    /**
+     * Authenticates the given user via OAuth Internal. Determines the tenant by itself via a call to tenant/currentTenant.
+     * Login call goes to `/tenant/oauth/token` and the retrieved token will be added in the `Authorization` header to subsequent requests.
+     *
+     * **Example**
+     * ```typescript
+     *
+     * let client: Client;
+     * (async () => {
+     *  client = await Client.authenticateViaOAuthInternal({
+     *    user: 'testuser',
+     *    password: 'password1337!'
+     *  }, 'https://acme.cumulocity.com');
+     *
+     *  //you have access to the client api now
+     *  const { data, paging, res }); =  await client.inventory.list({ pageSize: 100 });
+     * })();
+     * ```
+     */
+    static authenticateViaOAuthInternal(credentials: ICredentials, baseUrl?: string): Promise<Client>;
+    /**
+     * Authenticates the given user via OAuth Internal. Determines the tenant by itself via a call to tenant/currentTenant.
+     * Login call goes to `/tenant/oauth` and the retrieved token will be attached as a Cookie in browser environments to subsequent requests (using 'CookieAuth').
+     * In none browser environments (e.g. nodejs) the retrieved token will be added in the `Authorization` header to subsequent requests (using 'NodeJSCookieAuth').
+     *
+     * **Example**
+     * ```typescript
+     *
+     * let client: Client;
+     * (async () => {
+     *  client = await Client.authenticateViaOAuthInternalCookie({
+     *    user: 'testuser',
+     *    password: 'password1337!'
+     *  }, 'https://acme.cumulocity.com');
+     *
+     *  //you have access to the client api now
+     *  const { data, paging, res }); =  await client.inventory.list({ pageSize: 100 });
+     * })();
+     * ```
+     */
+    static authenticateViaOAuthInternalCookie(credentials: ICredentials, baseUrl?: string): Promise<Client>;
+    /**
+     * Allows to use http to register a device on the platform.
+     *
+     * **Deprecated** Please use MQTT to bootstrap a device.
+     */
+    static deviceBootstrap(options: IBootstrapOptions): Promise<Client>;
+    /**
+     * Retrieves microservice credentials for the subscribed tenants
+     * using provided bootstrap credentials
+     *
+     * **Example**
+     * ```typescript
+     *
+     * (async () => {
+     *  const subscriptions = await Client.getMicroserviceSubscriptions({
+     *    tenant: process.env.C8Y_BOOTSTRAP_TENANT,
+     *    user: process.env.C8Y_BOOTSTRAP_USER,
+     *    password: process.env.C8Y_BOOTSTRAP_PASSWORD
+     *  }, process.env.C8Y_BASEURL);
+     *
+     *  const clients = subscriptions.map(subscription => new Client(new BasicAuth(subscription), process.env.C8Y_BASEURL));
+     *  // you have access to the client api now
+     *  const promiseArray = clients.map(client => client.options.tenant.detail({
+     *    category: process.env.APPLICATION_KEY,
+     *    key: 'someSetting'
+     *  }));
+     * })();
+     * ```
+     */
+    static getMicroserviceSubscriptions(bootstrapCredentials: ICredentials, baseUrl: string): Promise<ICredentials[]>;
+    /**
+     * Performs the OAuth Internal login.
+     *
+     * If the parameter `bearerAuth` is set to true (default), the `/tenant/oauth/token` endpoint is called and a string containing the token returned.
+     *
+     * If the parameter `bearerAuth` is set to false, the `/tenant/oauth` endpoint is called and a Cookie should be set and the response returned.
+     * The response can be used in none browser environments to extract the `set-cookie` header from it.
+     *
+     * **Example**
+     * ```typescript
+     *
+     * (async () => {
+     *  const client = await Client.loginViaOAuthInternal({
+     *    tenant: process.env.C8Y_BOOTSTRAP_TENANT,
+     *    user: process.env.C8Y_BOOTSTRAP_USER,
+     *    password: process.env.C8Y_BOOTSTRAP_PASSWORD
+     *  }, true, process.env.C8Y_BASEURL);
+     *
+     *  // you have access to the client api now
+     *  const option = client.options.tenant.detail({
+     *    category: process.env.APPLICATION_KEY,
+     *    key: 'someSetting'
+     *  });
+     * })();
+     * ```
+     */
+    static loginViaOAuthInternal(credentials: ICredentials, bearerAuth?: true, baseUrl?: string): Promise<string>;
+    static loginViaOAuthInternal(credentials: ICredentials, bearerAuth: false, baseUrl?: string): Promise<IFetchResponse>;
+    private static getCurrentTenant;
+    alarm: AlarmService;
+    application: ApplicationService;
+    audit: AuditService;
+    core: FetchClient;
+    deviceRegistration: DeviceRegistrationService;
+    deviceRegistrationBulk: DeviceRegistrationBulkService;
+    event: EventService;
+    inventory: InventoryService;
+    inventoryRole: InventoryRoleService;
+    inventoryBinary: InventoryBinaryService;
+    measurement: MeasurementService;
+    operation: OperationService;
+    operationBulk: OperationBulkService;
+    options: {
+        security: TenantSecurityOptionsService;
+        system: SystemOptionsService;
+        login: TenantLoginOptionsService;
+        tenant: TenantOptionsService;
+    };
+    realtime: Realtime;
+    role: InventoryRoleService;
+    tenant: TenantService;
+    user: UserService;
+    userGroup: UserGroupService;
+    userRole: UserRoleService;
+    identity: IdentityService;
+    smartGroups: SmartGroupsService;
+    smartRules: SmartRulesService;
+    /**
+     * Initializes a new Client, which allows to request data from the API. Differently
+     * to Client.authenticate([...]) it needs a tenant given and does not verify if the
+     * login is correct.
+     *
+     * **Example**
+     * ```typescript
+     *
+     * const auth = new BasicAuth({
+     *   user: 'youruser',
+     *   password: 'yourpassword',
+     *   tenant: 'acme'
+     * }); // use CookieAuth() if your platform uses oauth (only in browser!)
+     *
+     * const baseUrl = 'https://acme.cumulocity.com';
+     * const client = new Client(auth, baseUrl);
+     * (async () => {
+     *   const { data, paging, res }); =  await client.inventory.list({ pageSize: 100 });
+     * })();
+     * ```
+     *
+     * @param auth The Authentication strategy to use (e.g. new BasicAuth())
+     * @param baseUrl The URL to request (optional in browser, mandatory in node)
+     */
+    constructor(auth: IAuthentication, baseUrl?: string);
+    /**
+     * Allows to change the current Authentication
+     * @param auth The new Authentication information.
+     */
+    setAuth(auth: IAuthentication): void;
+}
+//# sourceMappingURL=Client.d.ts.map

package/lib/cjs/src/alarm/AlarmService.d.ts

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

package/lib/cjs/src/alarm/AlarmStatus.d.ts

@@ -0,0 +1,9 @@
+/**
+ * A specific alarm can have one of the following states
+ */
+export declare enum AlarmStatus {
+    ACKNOWLEDGED,
+    CLEARED,
+    ACTIVE
+}
+//# sourceMappingURL=AlarmStatus.d.ts.map

package/lib/cjs/src/alarm/IAlarm.d.ts

@@ -0,0 +1,57 @@
+import { ISource, Severity } from '../core';
+import { AlarmStatus } from './AlarmStatus';
+export interface IAlarm {
+    /**
+     * Specifies the severity of an alarm
+     */
+    severity: Severity;
+    /**
+     * Specifies which device has the alarm
+     */
+    source: ISource;
+    /**
+     * Type of the alarm
+     */
+    type: string;
+    /**
+     * Time when the alarm occured
+     */
+    time: string;
+    /**
+     * Alarm text
+     */
+    text: string;
+    /**
+     * Identifier of the alarm
+     */
+    id?: string | number;
+    /**
+     * Current status of the alarm
+     */
+    status?: AlarmStatus;
+    /**
+     * How many times the same alarm appeared
+     */
+    count?: number;
+    /**
+     * Name of the alarm
+     */
+    name?: string;
+    /**
+     * Object with audit records as array
+     */
+    history?: object;
+    /**
+     * Self link to the alarm
+     */
+    self?: string;
+    /**
+     * When was the alarm created as first instance
+     */
+    creationTime?: string;
+    /**
+     * Other custom keys
+     */
+    [key: string]: any;
+}
+//# sourceMappingURL=IAlarm.d.ts.map

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

@@ -0,0 +1,4 @@
+export * from './AlarmService';
+export * from './AlarmStatus';
+export * from './IAlarm';
+//# sourceMappingURL=index.d.ts.map

package/lib/cjs/src/application/ApplicationAvailability.d.ts

@@ -0,0 +1,6 @@
+export declare enum ApplicationAvailability {
+    MARKET,
+    PRIVATE,
+    SHARED
+}
+//# sourceMappingURL=ApplicationAvailability.d.ts.map

package/lib/cjs/src/application/ApplicationBinaryService.d.ts

@@ -0,0 +1,40 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { IFetchClient, Service, IResult, IFetchResponse } from '../core';
+import { IApplication } from './IApplication';
+import { IApplicationBinary } from './IApplicationBinary';
+import { Stream } from 'stream';
+import { IUploadParamsOverride } from './IUploadParamsOverride';
+export declare class ApplicationBinaryService extends Service<IApplicationBinary> {
+    protected baseUrl: any;
+    protected listUrl: string;
+    protected propertyName: string;
+    constructor(client: IFetchClient, applicationOrId: string | number | IApplication);
+    upload(binary: ArrayBuffer | Stream | Buffer | File | Blob, fileName?: string, uploadParamsOverride?: IUploadParamsOverride): Promise<IResult<IApplicationBinary>>;
+    uploadWithProgressXhr(binary: ArrayBuffer | Stream | Buffer | File | Blob, onProgress: any, fileName?: string, uploadParamsOverride?: IUploadParamsOverride): XMLHttpRequest;
+    getXMLHttpResponse(xhr: any): Promise<IApplication>;
+    list(filter?: any): Promise<import("../core").IResultList<IApplicationBinary>>;
+    delete(binaryOrId: string | number | IApplicationBinary): Promise<IResult<null>>;
+    listPlugins(): Promise<{
+        res: IFetchResponse;
+        data: any;
+    }>;
+    addPlugin(pluginName: string, pluginFile: Stream | Buffer | ArrayBuffer): Promise<{
+        res: IFetchResponse;
+        data: any;
+    }>;
+    removePlugin(pluginName: string): Promise<{
+        res: IFetchResponse;
+        data: any;
+    }>;
+    updateFiles(files: Array<{
+        path: string;
+        contents: Stream | Buffer | ArrayBuffer;
+    }>): Promise<{
+        res: IFetchResponse;
+        data: any;
+    }>;
+    downloadArchive(binaryId: number | string): Promise<IFetchResponse>;
+    private createBinaryRequestBody;
+}
+//# sourceMappingURL=ApplicationBinaryService.d.ts.map