@space-df/sdk 0.0.1-dev.4 → 0.0.1-dev.40

package/dist/src/resources/device/device-connector.ts

@@ -0,0 +1,49 @@
+import { APIResource } from '../../resource';
+import * as Core from '../../core';
+
+export class DeviceConnector extends APIResource {
+    create(params: DeviceConnectorParams, options?: Core.RequestOptions): Core.APIPromise<DeviceConnectorParams> {
+        const { ...body } = params;
+        return this._client.post(`/device-connector/`, {
+            body,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    testConnectionPreview(params: DeviceConnectorParams, options?: Core.RequestOptions): Core.APIPromise<void> {
+        const { ...body } = params;
+        return this._client.post(`/device-connector/test-connection-preview/`, {
+            body,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    testConnection(id: string, options?: Core.RequestOptions): Core.APIPromise<void> {
+        return this._client.get(`/device-connector/${id}/`, {
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+}
+
+export interface DeviceConnectorParams {
+    network_server: string;
+    name: string;
+    connector_type: string;
+    status?: string;
+    deviceHttpConfig?: DeviceHttpConfig;
+    deviceMqttConfig?: DeviceMqttConfig;
+}
+
+export interface DeviceHttpConfig {
+    api_token: string;
+    address_url: string;
+}
+
+export interface DeviceMqttConfig {
+    mqtt_broker: string;
+    username: string;
+    password: string;
+}

package/dist/src/resources/device/device-model.ts

@@ -0,0 +1,65 @@
+import { APIResource } from '../../resource';
+import * as Core from '../../core';
+import { ListParamsResponse, ListResponse } from '../../types/api';
+
+export class DeviceModel extends APIResource {
+    create(params: DeviceModelParams, options?: Core.RequestOptions): Core.APIPromise<DeviceModelParams> {
+        const { ...body } = params;
+        return this._client.post(`/device-models/`, {
+            body,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    retrieve(id: string, options?: Core.RequestOptions): Core.APIPromise<DeviceModelParams> {
+        return this._client.get(`/device-models/${id}/`, {
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    update(id: string, params: DeviceModelParams, options?: Core.RequestOptions): Core.APIPromise<DeviceModelParams> {
+        const { ...body } = params;
+        return this._client.put(`/device-models/${id}/`, {
+            body,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    partialUpdate(id: number, params: DeviceModelParams, options?: Core.RequestOptions): Core.APIPromise<DeviceModelParams> {
+        const { ...body } = params;
+        return this._client.patch(`/device-models/${id}/`, {
+            body,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    list(params: ListParamsResponse, options?: Core.RequestOptions): Core.APIPromise<DeviceModelListResponse> {
+        const { ...query } = params;
+        return this._client.get(`/device-models/`, {
+            query,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    delete(id: number, options?: Core.RequestOptions): Core.APIPromise<void> {
+        return this._client.delete(`/device-models/${id}/`, {
+            ...options,
+            headers: { Accept: '*/*', ...options?.headers },
+        });
+    }
+}
+
+export interface DeviceModelParams {
+    name: string;
+    alias: string;
+    image_url: string;
+    default_config: object;
+    manufacture: string;
+}
+
+export type DeviceModelListResponse = ListResponse<DeviceModelParams>;

package/dist/src/resources/device/device-spaces.ts

@@ -0,0 +1,42 @@
+import { APIResource } from '../../resource';
+import * as Core from '../../core';
+import { ListParamsResponse, ListResponse } from '../../types/api';
+
+interface DeviceSpacesListParams extends ListParamsResponse {
+    include_latest_checkpoint?: boolean;
+}
+
+export class DeviceSpaces extends APIResource {
+    create(params: DeviceSpacesParams, options?: Core.RequestOptions): Core.APIPromise<DeviceSpacesParams> {
+        const { ...body } = params;
+        return this._client.post(`/device-spaces`, {
+            body,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    list(params: DeviceSpacesListParams, options?: Core.RequestOptions): Core.APIPromise<DeviceSpacesListResponse> {
+        const { ...query } = params;
+        return this._client.get(`/device-spaces`, {
+            query,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    delete(id: string, options?: Core.RequestOptions): Core.APIPromise<void> {
+        return this._client.delete(`/device-spaces/${id}`, {
+            ...options,
+            headers: { Accept: '*/*', ...options?.headers },
+        });
+    }
+}
+
+export interface DeviceSpacesParams {
+    name: string;
+    dev_eui: string;
+    description: string;
+}
+
+export type DeviceSpacesListResponse = ListResponse<DeviceSpacesParams>;

package/dist/src/resources/device/devices.ts

@@ -0,0 +1,70 @@
+import { APIResource } from '../../resource';
+import * as Core from '../../core';
+import { ListParamsResponse, ListResponse } from '../../types/api';
+
+export class Device extends APIResource {
+    create(params: DeviceParams, options?: Core.RequestOptions): Core.APIPromise<DeviceParams> {
+        const { ...body } = params;
+        return this._client.post(`/devices/`, {
+            body,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    retrieve(id: string, options?: Core.RequestOptions): Core.APIPromise<DeviceParams> {
+        return this._client.get(`/devices/${id}/`, {
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    update(id: string, params: DeviceParams, options?: Core.RequestOptions): Core.APIPromise<DeviceParams> {
+        const { ...body } = params;
+        return this._client.put(`/devices/${id}/`, {
+            body,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    partialUpdate(id: number, params: DeviceParams, options?: Core.RequestOptions): Core.APIPromise<DeviceParams> {
+        const { ...body } = params;
+        return this._client.patch(`/devices/${id}/`, {
+            body,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    list(params: ListParamsResponse, options?: Core.RequestOptions): Core.APIPromise<DeviceListResponse> {
+        const { ...query } = params;
+        return this._client.get(`/devices/`, {
+            query,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    delete(id: number, options?: Core.RequestOptions): Core.APIPromise<void> {
+        return this._client.delete(`/devices/${id}/`, {
+            ...options,
+            headers: { Accept: '*/*', ...options?.headers },
+        });
+    }
+
+    checkClaimCode(code: string, options?: Core.RequestOptions): Core.APIPromise<void> {
+        return this._client.get(`/devices/${code}/check`, {
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+}
+
+export interface DeviceParams {
+    status?: string;
+    device_connector: string;
+    device_model: string;
+}
+
+export type DeviceListResponse = ListResponse<DeviceParams>;

package/dist/src/resources/device/index.ts

@@ -0,0 +1,7 @@
+export * from './device-model';
+export * from './device-connector';
+export * from './network-server';
+export * from './devices';
+export * from './manufacturers';
+export * from './device-spaces';
+export * from './trip';

package/dist/src/resources/device/manufacturers.ts

@@ -0,0 +1,65 @@
+import { APIResource } from '../../resource';
+import * as Core from '../../core';
+import { ListParamsResponse, ListResponse } from '../../types/api';
+
+export class Manufacturers extends APIResource {
+    create(params: ManufacturersParams, options?: Core.RequestOptions): Core.APIPromise<ManufacturersParams> {
+        const { ...body } = params;
+        return this._client.post(`/manufacturers/`, {
+            body,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    retrieve(id: string, options?: Core.RequestOptions): Core.APIPromise<ManufacturersParams> {
+        return this._client.get(`/manufacturers/${id}/`, {
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    update(id: string, params: ManufacturersParams, options?: Core.RequestOptions): Core.APIPromise<ManufacturersParams> {
+        const { ...body } = params;
+        return this._client.put(`/manufacturers/${id}/`, {
+            body,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    partialUpdate(id: number, params: ManufacturersParams, options?: Core.RequestOptions): Core.APIPromise<ManufacturersParams> {
+        const { ...body } = params;
+        return this._client.patch(`/manufacturers/${id}/`, {
+            body,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    list(params: ListParamsResponse, options?: Core.RequestOptions): Core.APIPromise<ManufacturersListResponse> {
+        const { ...query } = params;
+        return this._client.get(`/manufacturers/`, {
+            query,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    delete(id: number, options?: Core.RequestOptions): Core.APIPromise<void> {
+        return this._client.delete(`/manufacturers/${id}/`, {
+            ...options,
+            headers: { Accept: '*/*', ...options?.headers },
+        });
+    }
+}
+
+export interface ManufacturersParams {
+    name: string;
+    location: string;
+    description: string;
+    portal_url: string;
+    national: string;
+}
+
+export type ManufacturersListResponse = ListResponse<ManufacturersParams>;

package/dist/src/resources/device/network-server.ts

@@ -0,0 +1,64 @@
+import { APIResource } from '../../resource';
+import * as Core from '../../core';
+import { ListParamsResponse, ListResponse } from '../../types/api';
+
+export class NetworkServer extends APIResource {
+    create(params: NetworkServerParams, options?: Core.RequestOptions): Core.APIPromise<NetworkServerParams> {
+        const { ...body } = params;
+        return this._client.post(`/network-server/`, {
+            body,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    retrieve(id: string, options?: Core.RequestOptions): Core.APIPromise<NetworkServerParams> {
+        return this._client.get(`/network-server/${id}/`, {
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    update(id: string, params: NetworkServerParams, options?: Core.RequestOptions): Core.APIPromise<NetworkServerParams> {
+        const { ...body } = params;
+        return this._client.put(`/network-server/${id}/`, {
+            body,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    partialUpdate(id: number, params: NetworkServerParams, options?: Core.RequestOptions): Core.APIPromise<NetworkServerParams> {
+        const { ...body } = params;
+        return this._client.patch(`/network-server/${id}/`, {
+            body,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    list(params: ListParamsResponse, options?: Core.RequestOptions): Core.APIPromise<NetworkServerListResponse> {
+        const { ...query } = params;
+        return this._client.get(`/network-server/`, {
+            query,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    delete(id: string, options?: Core.RequestOptions): Core.APIPromise<void> {
+        return this._client.delete(`/network-server/${id}/`, {
+            ...options,
+            headers: { Accept: '*/*', ...options?.headers },
+        });
+    }
+}
+
+export interface NetworkServerParams {
+    name: string;
+    logo: string;
+    description: string;
+    type_connect: string[];
+}
+
+export type NetworkServerListResponse = ListResponse<NetworkServerParams>;

package/dist/src/resources/device/trip.ts

@@ -0,0 +1,69 @@
+import { APIResource } from '../../resource';
+import { ListParamsResponse, ListResponse } from '../../types/api';
+import * as Core from '../../core';
+
+interface TripListParams extends ListParamsResponse {
+    include_checkpoints?: boolean;
+}
+
+export class Trip extends APIResource {
+    create(params: TripParams, options?: Core.RequestOptions): Core.APIPromise<TripParams> {
+        return this._client.post(`/trips/`, {
+            body: params,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    retrieve(id: string, params: TripListParams, options?: Core.RequestOptions): Core.APIPromise<TripParams> {
+        return this._client.get(`/trips/${id}/`, {
+            query: params,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    list(
+        params: TripListParams & {
+            space_device__device_id: string;
+        },
+        options?: Core.RequestOptions,
+    ): Core.APIPromise<TripListResponse> {
+        return this._client.get(`/trips/`, {
+            query: params,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    delete(id: string, options?: Core.RequestOptions): Core.APIPromise<void> {
+        return this._client.delete(`/trips/${id}/`, {
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    partialUpdate(id: string, params: TripParams, options?: Core.RequestOptions): Core.APIPromise<TripParams> {
+        return this._client.patch(`/trips/${id}/`, {
+            body: params,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    update(id: string, params: TripParams, options?: Core.RequestOptions): Core.APIPromise<TripParams> {
+        return this._client.put(`/trips/${id}/`, {
+            body: params,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+}
+
+export interface TripParams {
+    space_device: string;
+    start_at: string;
+    ended_at: string;
+}
+
+export type TripListResponse = ListResponse<TripParams>;

package/dist/src/resources/index.ts

@@ -4,3 +4,6 @@
 export * from './auth/index';
 export * from './dashboard/index';
 export * from './console/index';
+export * from './device/index';
+export * from './organizations/index';
+export * from './telemetry/index';

package/dist/src/resources/organizations/index.ts

@@ -0,0 +1 @@
+export * from './organizations';

package/dist/src/resources/organizations/organizations.ts

@@ -0,0 +1,12 @@
+import * as Core from '../../core';
+import { APIResource } from '../../resource';
+
+export class Organizations extends APIResource {
+    checkSlugName(slugName: string, options?: Core.RequestOptions): Core.APIPromise<CheckSlugNameResponse> {
+        return this._client.get(`/organizations/check/${slugName}`, options);
+    }
+}
+
+export interface CheckSlugNameResponse {
+    result: string;
+}

package/dist/src/resources/telemetry/alerts.ts

@@ -0,0 +1,27 @@
+import { APIResource } from '../../resource';
+import * as Core from '../../core';
+import { ListParamsResponse, ListResponse } from '../../types/api';
+
+export interface Alert {
+    [key: string]: any;
+}
+
+export type AlertsListResponse = ListResponse<Alert>;
+
+export interface AlertsListParams extends ListParamsResponse {
+    device_id?: string;
+    category?: string;
+    start_date?: string;
+    end_date?: string;
+}
+
+export class Alerts extends APIResource {
+    list(params: AlertsListParams, options?: Core.RequestOptions): Core.APIPromise<AlertsListResponse> {
+        const { ...query } = params;
+        return this._client.get(`/telemetry/v1/alerts`, {
+            query,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+}

package/dist/src/resources/telemetry/entities.ts

@@ -0,0 +1,51 @@
+import { APIResource } from '../../resource';
+import * as Core from '../../core';
+import { ListParamsResponse, ListResponse } from '../../types/api';
+
+export class Entities extends APIResource {
+    list(params: EntitiesListParams, options?: Core.RequestOptions): Core.APIPromise<EntitiesListResponse> {
+        const { ...query } = params;
+        return this._client.get(`/telemetry/v1/entities`, {
+            query,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+}
+
+export interface Entity {
+    category: string;
+    created_at: string;
+    device_id: string;
+    device_name: string;
+    display_type: string[];
+    entity_type: {
+        id: string;
+        image_url: string;
+        name: string;
+        unique_key: string;
+    };
+    id: string;
+    image_url: string;
+    is_enabled: boolean;
+    name: string;
+    time_end: string;
+    time_start: string;
+    unique_key: string;
+    unit_of_measurement: string;
+    updated_at: string;
+}
+
+export type EntitiesListResponse = ListResponse<Entity>;
+
+export interface EntitiesListParams extends ListParamsResponse {
+    /**
+     * Query param: Display type filter (e.g., "chart").
+     */
+    display_type?: string;
+
+    /**
+     * Query param: A search term.
+     */
+    search?: string;
+}

package/dist/src/resources/telemetry/geofences.ts

@@ -0,0 +1,91 @@
+import { APIResource } from '../../resource';
+import * as Core from '../../core';
+import { ListParamsResponse, ListResponse } from '../../types/api';
+
+type Condition =
+    | { time_between: { start: string; end: string } }
+    | { weekday_in: number[] }
+    | { distance_from_geofence_km: { lte: number } }
+    | { and: Condition[] }
+    | { or: Condition[] }
+    | { not: Condition[] };
+
+type Coordinate = [number, number];
+
+type PolygonGeometry = {
+    type: 'Polygon';
+    coordinates: Coordinate[][];
+    properties: {
+        mode: 'rectangle' | 'angled-rectangle' | string;
+    };
+};
+
+export interface Geofence {
+    id: string;
+    name: string;
+    color: string;
+    type_zone: 'safe' | 'danger';
+    definition: {
+        conditions: {
+            and: Condition[];
+        };
+    };
+    features: PolygonGeometry[];
+}
+
+export type GeofencesListResponse = ListResponse<Geofence>;
+
+export interface GeofencesListParams extends ListParamsResponse {
+    name?: string;
+    bbox?: string;
+}
+export class Geofences extends APIResource {
+    list(params: GeofencesListParams, options?: Core.RequestOptions): Core.APIPromise<GeofencesListResponse> {
+        const { ...query } = params;
+        return this._client.get(`/telemetry/v1/geofences`, {
+            query,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+    create(params: Omit<Geofence, 'id'>, options?: Core.RequestOptions): Core.APIPromise<Geofence> {
+        const { ...body } = params;
+        return this._client.post(`/telemetry/v1/geofences`, {
+            body,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    retrieve(id: string, options?: Core.RequestOptions): Core.APIPromise<Geofence> {
+        return this._client.get(`/telemetry/v1/geofences/${id}`, {
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    update(id: string, params: Omit<Geofence, 'id'>, options?: Core.RequestOptions): Core.APIPromise<Geofence> {
+        const { ...body } = params;
+        return this._client.put(`/telemetry/v1/geofences/${id}`, {
+            body,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    delete(id: string, options?: Core.RequestOptions): Core.APIPromise<void> {
+        return this._client.delete(`/telemetry/v1/geofences/${id}`, {
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    test(params: Omit<Geofence, 'id' | 'name' | 'color'>, options?: Core.RequestOptions): Core.APIPromise<void> {
+        const { ...body } = params;
+        return this._client.post(`/telemetry/v1/geofences/test`, {
+            body,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+}

package/dist/src/resources/telemetry/index.ts

@@ -0,0 +1,12 @@
+import { APIResource } from "../../resource";
+import { Entities } from './entities';
+import { Alerts } from './alerts';
+import { Geofences } from './geofences';
+
+export class Telemetry extends APIResource {
+    entities: Entities = new Entities(this._client);
+    alerts: Alerts = new Alerts(this._client);
+    geofences: Geofences = new Geofences(this._client);
+}
+
+export * from './entities';

package/dist/src/version.ts

@@ -1 +1 @@
-export const VERSION = '0.0.1-dev.4';
+export const VERSION = '0.0.1-dev.40';

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.0.1-dev.4";
+export declare const VERSION = "0.0.1-dev.40";
 //# sourceMappingURL=version.d.ts.map

package/dist/version.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["src/version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,gBAAgB,CAAC"}
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["src/version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,iBAAiB,CAAC"}

package/dist/version.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
-exports.VERSION = '0.0.1-dev.4';
+exports.VERSION = '0.0.1-dev.40';
 //# sourceMappingURL=version.js.map

package/dist/version.js.map

@@ -1 +1 @@
-{"version":3,"file":"version.js","sourceRoot":"","sources":["src/version.ts"],"names":[],"mappings":";;;AAAa,QAAA,OAAO,GAAG,aAAa,CAAC"}
+{"version":3,"file":"version.js","sourceRoot":"","sources":["src/version.ts"],"names":[],"mappings":";;;AAAa,QAAA,OAAO,GAAG,cAAc,CAAC"}

package/dist/version.mjs

@@ -1,2 +1,2 @@
-export const VERSION = '0.0.1-dev.4';
+export const VERSION = '0.0.1-dev.40';
 //# sourceMappingURL=version.mjs.map