@space-df/sdk 0.0.1-dev.3.3 → 0.0.1-dev.31

package/dist/src/resources/auth/space-role-users.ts

@@ -0,0 +1,79 @@
+import { APIResource } from '../../resource';
+import { ListParamsResponse, ListResponse } from '../../types/api';
+import * as Core from '../../core';
+
+export class SpaceRoleUsers extends APIResource {
+    retrieve(id: number, params: SpaceRoleUsersParams, options?: Core.RequestOptions): Core.APIPromise<SpaceRoleUser> {
+        const { 'X-Space': xspace } = params;
+        return this._client.get(`/space-role-users/${id}`, {
+            ...options,
+            headers: { ...options?.headers, 'X-Space': xspace },
+        });
+    }
+
+    list(spaceName: string, params: ListParamsResponse, options?: Core.RequestOptions): Core.APIPromise<SpaceRoleUserListResponse> {
+        const { ...query } = params;
+        return this._client.get(`/space-role-users`, {
+            query,
+            ...options,
+            headers: { ...options?.headers, 'X-Space': spaceName },
+        });
+    }
+
+    update(id: number, params: SpaceRoleUserUpdateParams, options?: Core.RequestOptions): Core.APIPromise<SpaceRoleUserUpdateParams> {
+        const { 'X-Space': xspace, ...body } = params;
+        return this._client.put(`/space-role-users/${id}`, {
+            body,
+            ...options,
+            headers: { ...options?.headers, 'X-Space': xspace },
+        });
+    }
+
+    partialUpdate(id: number, params: SpaceRoleUserUpdateParams, options?: Core.RequestOptions): Core.APIPromise<SpaceRoleUserUpdateParams> {
+        const { 'X-Space': xspace, ...body } = params;
+        return this._client.patch(`/space-role-users/${id}`, {
+            body,
+            ...options,
+            headers: { ...options?.headers, 'X-Space': xspace },
+        });
+    }
+
+    setSpaceDefault(id: String, params: SpaceRoleUsersParams, options?: Core.RequestOptions): Core.APIPromise<void> {
+        const { 'X-Space': xspace } = params;
+        return this._client.post(`/space-role-users/${id}/default`, {
+            ...options,
+            headers: { ...options?.headers, 'X-Space': xspace },
+        });
+    }
+
+    delete(id: number, params: SpaceRoleUsersParams, options?: Core.RequestOptions): Core.APIPromise<void> {
+        const { 'X-Space': xspace } = params;
+        return this._client.delete(`/space-role-users/${id}`, {
+            ...options,
+            headers: { Accept: '*/*', ...options?.headers, 'X-Space': xspace },
+        });
+    }
+}
+
+export interface SpaceRoleUser {
+    organization_user: number;
+
+    space_role: number;
+
+    id?: number;
+
+    readonly created_at?: string;
+
+    readonly updated_at?: string;
+}
+
+export interface SpaceRoleUserUpdateParams {
+    space_role: string;
+    'X-Space': string;
+}
+
+export interface SpaceRoleUsersParams {
+    'X-Space': string;
+}
+
+export type SpaceRoleUserListResponse = ListResponse<SpaceRoleUser>;

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

@@ -0,0 +1,110 @@
+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 { 'X-Space': xspace, ...body } = params;
+        return this._client.post(`/space-roles`, {
+            body,
+            ...options,
+            headers: { ...options?.headers, 'X-Space': xspace },
+        });
+    }
+
+    retrieve(id: number, params: SpaceRoleParams, options?: Core.RequestOptions): Core.APIPromise<SpaceRole> {
+        const { 'X-Space': xspace } = params;
+        return this._client.get(`/space-roles/${id}`, {
+            ...options,
+            headers: { ...options?.headers, 'X-Space': xspace },
+        });
+    }
+
+    update(id: number, params: SpaceRoleUpdateParams, options?: Core.RequestOptions): Core.APIPromise<SpaceRole> {
+        const { 'X-Space': xspace, ...body } = params;
+        return this._client.put(`/space-roles/${id}`, {
+            body,
+            ...options,
+            headers: { ...options?.headers, 'X-Space': xspace },
+        });
+    }
+
+    partialUpdate(id: number, params: SpaceRoleUpdateParams, options?: Core.RequestOptions): Core.APIPromise<SpaceRole> {
+        const { 'X-Space': xspace, ...body } = params;
+        return this._client.patch(`/space-roles/${id}`, {
+            body,
+            ...options,
+            headers: { ...options?.headers, 'X-Space': xspace },
+        });
+    }
+
+    list(spaceName: string, params: ListParamsResponse, options?: Core.RequestOptions): Core.APIPromise<SpaceRoleListResponse> {
+        const { ...query } = params;
+        return this._client.get(`/space-roles`, {
+            query,
+            ...options,
+            headers: { ...options?.headers, 'X-Space': spaceName },
+        });
+    }
+
+    delete(id: number, params: SpaceRoleParams, options?: Core.RequestOptions): Core.APIPromise<void> {
+        const { 'X-Space': xspace } = params;
+        return this._client.delete(`/space-roles/${id}`, {
+            ...options,
+            headers: { Accept: '*/*', ...options?.headers, 'X-Space': xspace },
+        });
+    }
+}
+
+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>;
+
+    /**
+     * Header param:
+     */
+    'X-Space': string;
+}
+
+export interface SpaceRoleUpdateParams {
+    /**
+     * Body param:
+     */
+    name: string;
+
+    /**
+     * Body param:
+     */
+    policies: Array<number>;
+    /**
+     * Header param:
+     */
+    'X-Space': string;
+}
+
+export interface SpaceRoleParams {
+    'X-Space': string;
+}

package/dist/src/resources/auth/spaces.ts

@@ -0,0 +1,145 @@
+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 { 'X-Space': xspace, ...body } = params;
+        return this._client.put(`/spaces`, {
+            body,
+            ...options,
+            headers: { ...options?.headers, 'X-Space': xspace },
+        });
+    }
+
+    partialUpdate(params: Partial<SpaceUpdateParams>, options?: Core.RequestOptions): Core.APIPromise<Space> {
+        const { 'X-Space': xspace, ...body } = params;
+        return this._client.patch(`/spaces`, {
+            body,
+            ...options,
+            headers: { ...options?.headers, 'X-Space': xspace },
+        });
+    }
+
+    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(params: SpaceParams, options?: Core.RequestOptions): Core.APIPromise<void> {
+        const { 'X-Space': xspace } = params;
+        return this._client.delete(`/spaces`, {
+            ...options,
+            headers: { Accept: '*/*', ...options?.headers, 'X-Space': xspace },
+        });
+    }
+
+    invitation(params: OAuthInvitationParams, options?: Core.RequestOptions): Core.APIPromise<OAuthInvitationParams> {
+        const { 'X-Space': xspace, ...body } = params;
+        return this._client.post(`/spaces/invitation`, {
+            body,
+            ...options,
+            headers: { ...options?.headers, 'X-Space': xspace },
+        });
+    }
+
+    joinSpace(token: string, options?: Core.RequestOptions): Core.APIPromise<JoinSpaceResponse> {
+        return this._client.get(`/spaces/join-space/${token}`, options);
+    }
+}
+
+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;
+
+    /**
+     * Header param:
+     */
+    'X-Space': string;
+}
+
+export interface SpaceParams {
+    'X-Space': string;
+}
+
+export interface SpaceUpdateParams {
+    /**
+     * Body param:
+     */
+    logo: string;
+
+    /**
+     * Body param:
+     */
+    name: string;
+
+    /**
+     * Body param:
+     */
+    is_active?: boolean;
+}
+
+export interface OAuthInvitationParams {
+    receiver_list: Receiver[];
+    'X-Space': string;
+}
+
+export interface Receiver {
+    email: string;
+    space_role_id: string;
+}
+
+export interface JoinSpaceResponse {
+    error?: string;
+    result?: string;
+}

package/dist/src/resources/auth/users.ts

@@ -0,0 +1,36 @@
+import { APIResource } from '../../resource';
+import * as Core from '../../core';
+
+export class Users extends APIResource {
+    getMe(options?: Core.RequestOptions): Core.APIPromise<Profile> {
+        return this._client.get(`/users/me`, options);
+    }
+
+    updateMe(body: Profile, options?: Core.RequestOptions): Core.APIPromise<Profile> {
+        return this._client.put(`/users/me`, { body, ...options });
+    }
+
+    deleteMe(options?: Core.RequestOptions): Core.APIPromise<void> {
+        return this._client.delete(`/users/me`, options);
+    }
+}
+
+export interface Profile {
+    id?: string;
+
+    first_name?: string;
+
+    last_name?: string;
+
+    email?: string;
+
+    location?: string;
+
+    avatar?: string;
+
+    company_name?: string;
+
+    title?: string;
+
+    is_owner?: boolean;
+}

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

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

package/dist/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/dist/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;
+}