@space-df/sdk 0.0.1-dev.3.1

package/src/resources/auth/space-roles.ts

@@ -0,0 +1,95 @@
+import { APIResource } from '../../resource';
+import { ListParamsResponse, ListResponse } from '../../types/api';
+import * as Core from '../../core';
+
+export class SpaceRoles extends APIResource {
+    create(params: SpaceRoleCreateParams, options?: Core.RequestOptions): Core.APIPromise<SpaceRole> {
+        const { ...body } = params;
+        return this._client.post(`/space-roles`, {
+            body,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    retrieve(id: number, options?: Core.RequestOptions): Core.APIPromise<SpaceRole> {
+        return this._client.get(`/space-roles/${id}`, {
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    update(id: number, params: SpaceRoleUpdateParams, options?: Core.RequestOptions): Core.APIPromise<SpaceRole> {
+        const { ...body } = params;
+        return this._client.put(`/space-roles/${id}`, {
+            body,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    partialUpdate(id: number, params: SpaceRoleUpdateParams, options?: Core.RequestOptions): Core.APIPromise<SpaceRole> {
+        const { ...body } = params;
+        return this._client.patch(`/space-roles/${id}`, {
+            body,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    list(params: ListParamsResponse, options?: Core.RequestOptions): Core.APIPromise<SpaceRoleListResponse> {
+        const { ...query } = params;
+        return this._client.get(`/space-roles`, {
+            query,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    delete(id: number, options?: Core.RequestOptions): Core.APIPromise<void> {
+        return this._client.delete(`/space-roles/${id}`, {
+            ...options,
+            headers: { Accept: '*/*', ...options?.headers },
+        });
+    }
+}
+
+export interface SpaceRole {
+    name: string;
+
+    policies: Array<number>;
+
+    id?: number;
+
+    readonly created_at?: string;
+
+    space?: number;
+
+    updated_at?: string;
+}
+
+export type SpaceRoleListResponse = ListResponse<SpaceRole>;
+
+export interface SpaceRoleCreateParams {
+    /**
+     * Body param:
+     */
+    name: string;
+
+    /**
+     * Body param:
+     */
+    policies: Array<number>;
+}
+
+export interface SpaceRoleUpdateParams {
+    /**
+     * Body param:
+     */
+    name: string;
+
+    /**
+     * Body param:
+     */
+    policies: Array<number>;
+}

package/src/resources/auth/spaces.ts

@@ -0,0 +1,118 @@
+import { APIResource } from '../../resource';
+import { isRequestOptions } from '../../core';
+import { ListParamsResponse, ListResponse } from '../../types/api';
+import * as Core from '../../core';
+
+export class Spaces extends APIResource {
+    create(body: SpaceCreateParams, options?: Core.RequestOptions): Core.APIPromise<Space> {
+        return this._client.post(`/spaces`, { body, ...options });
+    }
+
+    update(params: SpaceUpdateParams, options?: Core.RequestOptions): Core.APIPromise<Space> {
+        const { ...body } = params;
+        return this._client.put(`/spaces`, {
+            body,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    partialUpdate(params: SpaceUpdateParams, options?: Core.RequestOptions): Core.APIPromise<Space> {
+        const { ...body } = params;
+        return this._client.patch(`/spaces`, {
+            body,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    list(params?: ListParamsResponse, options?: Core.RequestOptions): Core.APIPromise<SpaceListResponse>;
+    list(options?: Core.RequestOptions): Core.APIPromise<SpaceListResponse>;
+    list(params: ListParamsResponse | Core.RequestOptions = {}, options?: Core.RequestOptions): Core.APIPromise<SpaceListResponse> {
+        if (isRequestOptions(params)) {
+            return this.list({}, params);
+        }
+        const { ...query } = params;
+        return this._client.get(`/spaces`, {
+            query,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    delete(options?: Core.RequestOptions): Core.APIPromise<void> {
+        return this._client.delete(`/spaces`, {
+            ...options,
+            headers: { Accept: '*/*', ...options?.headers },
+        });
+    }
+}
+
+export interface Space {
+    logo: string;
+
+    name: string;
+
+    slug_name: string;
+
+    id?: number;
+
+    created_by?: number | null;
+
+    is_active?: boolean;
+
+    total_devices: number;
+
+    readonly created_at?: string;
+
+    readonly updated_at?: string;
+}
+
+export type SpaceListResponse = ListResponse<Space>;
+
+export interface SpaceCreateParams {
+    logo: string;
+
+    name: string;
+
+    slug_name: string;
+}
+
+export interface SpaceUpdateParams {
+    /**
+     * Body param:
+     */
+    logo: string;
+
+    /**
+     * Body param:
+     */
+    name: string;
+
+    /**
+     * Body param:
+     */
+    slug_name: string;
+}
+
+export interface SpaceUpdateParams {
+    /**
+     * Body param:
+     */
+    logo: string;
+
+    /**
+     * Body param:
+     */
+    name: string;
+
+    /**
+     * Body param:
+     */
+    slug_name: string;
+
+    /**
+     * Body param:
+     */
+    is_active?: boolean;
+}

package/src/resources/console/index.ts

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

package/src/resources/console/oauth2.ts

@@ -0,0 +1,83 @@
+import { APIResource } from '../../resource';
+import * as Core from '../../core';
+import { rstripBase64, toBase64, toSHA256, uuid4 } from '../../libs/utils';
+
+export class OAuth2 extends APIResource {
+    async authorize(body: OAuth2AuthorizeParams, options?: Core.RequestOptions): Promise<OAuth2Authorize> {
+        const verifier = rstripBase64(toBase64(uuid4()));
+        const codeChallenge = rstripBase64(toBase64(await toSHA256(verifier)));
+
+        const oAuth2AuthorizeBody: OAuth2Authorize = {
+            ...body,
+            response_type: 'code',
+            code_challenge: codeChallenge,
+            code_challenge_method: 'S256',
+        };
+
+        return (
+            this._client.post(`/auth/login`, { body: oAuth2AuthorizeBody, ...options }) as Core.APIPromise<{
+                data: OAuth2Authorize;
+            }>
+        )._thenUnwrap((obj) => ({ ...obj.data, verifier }));
+    }
+}
+
+export type OAuth2AuthorizeParams = Pick<OAuth2Authorize, 'client_id' | 'redirect_uri' | 'scopes'>;
+
+export interface OAuth2Authorize {
+    /**
+     * Response type
+     */
+    response_type: 'code';
+
+    /**
+     * Code challenge, require min length > 1
+     */
+    code_challenge: string;
+
+    /**
+     * Code challenge method
+     */
+    code_challenge_method: 'plain' | 'S256';
+
+    /**
+     * Client id
+     */
+    client_id: string;
+
+    /**
+     * Redirect uri
+     */
+    redirect_uri: string;
+
+    scopes: Array<'organization'>;
+}
+
+export interface OAuth2Token {
+    /**
+     * Client id
+     */
+    client_id: string;
+
+    /**
+     * Client secret
+     */
+    client_secret: string;
+
+    /**
+     * Code
+     */
+    code: string;
+
+    /**
+     * Code verifier
+     */
+    code_verifier: string;
+
+    readonly scopes?: Array<'organization'>;
+
+    /**
+     * Id token
+     */
+    readonly id_token?: string;
+}

package/src/resources/dashboard/dashboards.ts

@@ -0,0 +1,171 @@
+import { APIResource } from '../../resource';
+import * as Core from '../../core';
+import { ListParamsResponse, ListResponse } from '../../types/api';
+
+export class Dashboards extends APIResource {
+    create(params: DashboardCreateParams, options?: Core.RequestOptions): Core.APIPromise<Dashboard> {
+        const { ...body } = params;
+        return this._client.post(`/dashboards`, {
+            body,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    retrieve(id: number, options?: Core.RequestOptions): Core.APIPromise<Dashboard> {
+        return this._client.get(`/dashboards/${id}`, {
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    update(id: number, params: DashboardUpdateParams, options?: Core.RequestOptions): Core.APIPromise<Dashboard> {
+        const { ...body } = params;
+        return this._client.put(`/dashboards/${id}`, {
+            body,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    partialUpdate(id: number, params: DashboardUpdateParams, options?: Core.RequestOptions): Core.APIPromise<Dashboard> {
+        const { ...body } = params;
+        return this._client.patch(`/dashboards/${id}`, {
+            body,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    list(params: ListParamsResponse, options?: Core.RequestOptions): Core.APIPromise<DashboardListResponse> {
+        const { ...query } = params;
+        return this._client.get(`/dashboards`, {
+            query,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    delete(id: number, options?: Core.RequestOptions): Core.APIPromise<void> {
+        return this._client.delete(`/dashboards/${id}`, {
+            ...options,
+            headers: { Accept: '*/*', ...options?.headers },
+        });
+    }
+
+    createWidget(dashboardId: string, params: WidgetCreateParams, options?: Core.RequestOptions): Core.APIPromise<Widget> {
+        const { ...body } = params;
+        return this._client.post(`/dashboards/${dashboardId}/widgets`, {
+            body,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    retrieveWidget(dashboardId: string, id: number, options?: Core.RequestOptions): Core.APIPromise<Widget> {
+        return this._client.get(`/dashboards/${dashboardId}/widgets/${id}`, {
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    updateWidget(dashboardId: string, id: number, params: WidgetUpdateParams, options?: Core.RequestOptions): Core.APIPromise<Widget> {
+        const { ...body } = params;
+        return this._client.put(`/dashboards/${dashboardId}/widgets/${id}`, {
+            body,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    partialUpdateWidget(dashboardId: string, id: number, params: WidgetUpdateParams, options?: Core.RequestOptions): Core.APIPromise<Widget> {
+        const { ...body } = params;
+        return this._client.patch(`/dashboards/${dashboardId}/widgets/${id}`, {
+            body,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    listWidgets(dashboardId: string, params: WidgetListParams, options?: Core.RequestOptions): Core.APIPromise<WidgetListResponse> {
+        const { ...query } = params;
+        return this._client.get(`/dashboards/${dashboardId}/widgets`, {
+            query,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    deleteWidget(dashboardId: string, id: number, options?: Core.RequestOptions): Core.APIPromise<void> {
+        return this._client.delete(`/dashboards/${dashboardId}/widgets/${id}`, {
+            ...options,
+            headers: { Accept: '*/*', ...options?.headers },
+        });
+    }
+}
+
+export interface Dashboard {
+    name: string;
+
+    id?: number;
+
+    space?: number;
+
+    readonly created_at?: string;
+
+    readonly updated_at?: string;
+}
+
+export type DashboardListResponse = ListResponse<Dashboard>;
+
+export interface DashboardCreateParams {
+    /**
+     * Body param:
+     */
+    name: string;
+}
+
+export interface DashboardUpdateParams {
+    /**
+     * Body param:
+     */
+    name: string;
+}
+
+/** ------------------------------------
+ * Widget type
+ ---------------------------------------*/
+export interface Widget {
+    readonly id?: number;
+
+    configuration: any;
+
+    readonly dashboard?: number;
+
+    readonly created_at?: string;
+
+    readonly updated_at?: string;
+}
+
+export type WidgetListResponse = Array<Widget>;
+
+export interface WidgetCreateParams {
+    /**
+     * Body param:
+     */
+    configuration: any;
+}
+
+export interface WidgetUpdateParams {
+    /**
+     * Body param:
+     */
+    configuration: any;
+}
+
+export interface WidgetListParams {
+    /**
+     * Query param: Which field to use when ordering the results.
+     */
+    ordering?: string;
+}

package/src/resources/dashboard/device-states.ts

@@ -0,0 +1,142 @@
+import { APIResource } from '../../resource';
+import { ListParamsResponse, ListResponse } from '../../types/api';
+import * as Core from '../../core';
+
+export class DeviceStates extends APIResource {
+    retrieveDaily(params: DailyRetrieveParams, options?: Core.RequestOptions): Core.APIPromise<DailyRetrieveResponse> {
+        const { ...query } = params;
+        return this._client.get(`/device-states/daily`, {
+            query,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    retrieveHourly(params: HourlyRetrieveParams, options?: Core.RequestOptions): Core.APIPromise<HourlyRetrieveResponse> {
+        const { ...query } = params;
+        return this._client.get(`/device-states/hourly`, {
+            query,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    retrieveMinutely(params: MinutelyRetrieveParams, options?: Core.RequestOptions): Core.APIPromise<MinutelyRetrieveResponse> {
+        const { ...query } = params;
+        return this._client.get(`/device-states/minutely`, {
+            query,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+
+    retrieveMonthly(params: MonthlyRetrieveParams, options?: Core.RequestOptions): Core.APIPromise<MonthlyRetrieveResponse> {
+        const { ...query } = params;
+        return this._client.get(`/device-states/monthly`, {
+            query,
+            ...options,
+            headers: { ...options?.headers },
+        });
+    }
+}
+
+export type DeviceStateListResponse<T> = ListResponse<T>;
+
+export interface DeviceStateListParams extends Omit<ListParamsResponse, 'search'> {
+    /**
+     * Query param: device_slug_name
+     */
+    device_slug_name?: string;
+
+    /**
+     * Query param: state_name
+     */
+    state_name?: string;
+}
+
+export type DailyRetrieveResponse = DeviceStateListResponse<DailyRetrieveResult>;
+
+export interface DailyRetrieveResult {
+    device_slug_name: string;
+
+    from_timestamp: string;
+
+    space: number;
+
+    state_name: string;
+
+    value: string;
+
+    id?: number;
+
+    readonly created_at?: string;
+
+    readonly updated_at?: string;
+}
+
+export type DailyRetrieveParams = DeviceStateListParams;
+
+export type MinutelyRetrieveResponse = ListResponse<MinutelyRetrieveResult>;
+
+export interface MinutelyRetrieveResult {
+    device_slug_name: string;
+
+    from_timestamp: string;
+
+    space: number;
+
+    state_name: string;
+
+    value: string;
+
+    id?: number;
+
+    readonly created_at?: string;
+
+    readonly updated_at?: string;
+}
+
+export type MinutelyRetrieveParams = DeviceStateListParams;
+
+export type MonthlyRetrieveResponse = ListResponse<MonthlyRetrieveResult>;
+
+export interface MonthlyRetrieveResult {
+    device_slug_name: string;
+
+    from_timestamp: string;
+
+    space: number;
+
+    state_name: string;
+
+    value: string;
+
+    id?: number;
+
+    readonly created_at?: string;
+
+    readonly updated_at?: string;
+}
+
+export type MonthlyRetrieveParams = DeviceStateListParams;
+
+export type HourlyRetrieveResponse = ListResponse<HourlyRetrieveResult>;
+export interface HourlyRetrieveResult {
+    device_slug_name: string;
+
+    from_timestamp: string;
+
+    space: number;
+
+    state_name: string;
+
+    value: string;
+
+    id?: number;
+
+    readonly created_at?: string;
+
+    readonly updated_at?: string;
+}
+
+export type HourlyRetrieveParams = DeviceStateListParams;

package/src/resources/dashboard/index.ts

@@ -0,0 +1,2 @@
+export * from './dashboards';
+export * from './device-states';

package/src/resources/index.ts

@@ -0,0 +1,6 @@
+/**
+ * https://hacks.mozilla.org/2015/08/es6-in-depth-modules/
+ */
+export * from './auth/index';
+export * from './dashboard/index';
+export * from './console/index';

package/src/shims/node.ts

@@ -0,0 +1,50 @@
+// @ts-ignore
+import * as types from '../_shims/node-types';
+import { setShims } from '../_shims/registry';
+import { getRuntime } from '../_shims/node-runtime';
+setShims(getRuntime());
+
+declare module '../_shims/manual-types' {
+    export namespace manual {
+        // @ts-ignore
+        export type Agent = types.Agent;
+        // @ts-ignore
+        export import fetch = types.fetch;
+        // @ts-ignore
+        export type Request = types.Request;
+        // @ts-ignore
+        export type RequestInfo = types.RequestInfo;
+        // @ts-ignore
+        export type RequestInit = types.RequestInit;
+        // @ts-ignore
+        export type Response = types.Response;
+        // @ts-ignore
+        export type ResponseInit = types.ResponseInit;
+        // @ts-ignore
+        export type ResponseType = types.ResponseType;
+        // @ts-ignore
+        export type BodyInit = types.BodyInit;
+        // @ts-ignore
+        export type Headers = types.Headers;
+        // @ts-ignore
+        export type HeadersInit = types.HeadersInit;
+        // @ts-ignore
+        export type BlobPropertyBag = types.BlobPropertyBag;
+        // @ts-ignore
+        export type FilePropertyBag = types.FilePropertyBag;
+        // @ts-ignore
+        export type FileFromPathOptions = types.FileFromPathOptions;
+        // @ts-ignore
+        export import FormData = types.FormData;
+        // @ts-ignore
+        export import File = types.File;
+        // @ts-ignore
+        export import Blob = types.Blob;
+        // @ts-ignore
+        export type Readable = types.Readable;
+        // @ts-ignore
+        export type FsReadStream = types.FsReadStream;
+        // @ts-ignore
+        export import ReadableStream = types.ReadableStream;
+    }
+}