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

package/src/_shims/auto/types.d.ts

@@ -4,43 +4,43 @@
 export type Agent = any;
 
 // @ts-ignore
-declare const _fetch:                                        typeof fetch;
+declare const _fetch: unknown extends typeof fetch ? never : typeof fetch;
 export { _fetch as fetch };
 
 // @ts-ignore
-type _Request =                                   Request;
+type _Request = unknown extends Request ? never : Request;
 export { _Request as Request };
 
 // @ts-ignore
-type _RequestInfo =                                       RequestInfo;
+type _RequestInfo = unknown extends RequestInfo ? never : RequestInfo;
 export { type _RequestInfo as RequestInfo };
 
 // @ts-ignore
-type _RequestInit =                                       RequestInit;
+type _RequestInit = unknown extends RequestInit ? never : RequestInit;
 export { type _RequestInit as RequestInit };
 
 // @ts-ignore
-type _Response =                                    Response;
+type _Response = unknown extends Response ? never : Response;
 export { _Response as Response };
 
 // @ts-ignore
-type _ResponseInit =                                        ResponseInit;
+type _ResponseInit = unknown extends ResponseInit ? never : ResponseInit;
 export { type _ResponseInit as ResponseInit };
 
 // @ts-ignore
-type _ResponseType =                                        ResponseType;
+type _ResponseType = unknown extends ResponseType ? never : ResponseType;
 export { type _ResponseType as ResponseType };
 
 // @ts-ignore
-type _BodyInit =                                    BodyInit;
+type _BodyInit = unknown extends BodyInit ? never : BodyInit;
 export { type _BodyInit as BodyInit };
 
 // @ts-ignore
-type _Headers =                                   Headers;
+type _Headers = unknown extends Headers ? never : Headers;
 export { _Headers as Headers };
 
 // @ts-ignore
-type _HeadersInit =                                       HeadersInit;
+type _HeadersInit = unknown extends HeadersInit ? never : HeadersInit;
 export { type _HeadersInit as HeadersInit };
 
 type EndingType = 'native' | 'transparent';
@@ -57,21 +57,21 @@ export interface FilePropertyBag extends BlobPropertyBag {
 export type FileFromPathOptions = Omit<FilePropertyBag, 'lastModified'>;
 
 // @ts-ignore
-type _FormData =                                    FormData;
+type _FormData = unknown extends FormData ? never : FormData;
 // @ts-ignore
-declare const _FormData:                                           typeof FormData;
+declare const _FormData: unknown extends typeof FormData ? never : typeof FormData;
 export { _FormData as FormData };
 
 // @ts-ignore
-type _File =                                File;
+type _File = unknown extends File ? never : File;
 // @ts-ignore
-declare const _File:                                       typeof File;
+declare const _File: unknown extends typeof File ? never : typeof File;
 export { _File as File };
 
 // @ts-ignore
-type _Blob =                                Blob;
+type _Blob = unknown extends Blob ? never : Blob;
 // @ts-ignore
-declare const _Blob:                                       typeof Blob;
+declare const _Blob: unknown extends typeof Blob ? never : typeof Blob;
 export { _Blob as Blob };
 
 export declare class Readable {
@@ -95,7 +95,7 @@ export declare class FsReadStream extends Readable {
 }
 
 // @ts-ignore
-type _ReadableStream<R = any> =                                             ReadableStream<R>;
+type _ReadableStream<R = any> = unknown extends ReadableStream<R> ? never : ReadableStream<R>;
 // @ts-ignore
-declare const _ReadableStream:                                                 typeof ReadableStream;
+declare const _ReadableStream: unknown extends typeof ReadableStream ? never : typeof ReadableStream;
 export { _ReadableStream as ReadableStream };

package/src/_shims/index-deno.ts

@@ -0,0 +1,105 @@
+import { MultipartBody } from './MultipartBody';
+import { type RequestOptions } from '../core';
+
+export const kind: string = 'web';
+
+export type Agent = any;
+
+const _fetch = fetch;
+type _fetch = typeof fetch;
+export { _fetch as fetch };
+
+const _Request = Request;
+type _Request = Request;
+export { _Request as Request };
+
+type _RequestInfo = RequestInfo;
+export { type _RequestInfo as RequestInfo };
+
+type _RequestInit = RequestInit;
+export { type _RequestInit as RequestInit };
+
+const _Response = Response;
+type _Response = Response;
+export { _Response as Response };
+
+type _ResponseInit = ResponseInit;
+export { type _ResponseInit as ResponseInit };
+
+type _ResponseType = ResponseType;
+export { type _ResponseType as ResponseType };
+
+type _BodyInit = BodyInit;
+export { type _BodyInit as BodyInit };
+
+const _Headers = Headers;
+type _Headers = Headers;
+export { _Headers as Headers };
+
+type _HeadersInit = HeadersInit;
+export { type _HeadersInit as HeadersInit };
+
+type EndingType = 'native' | 'transparent';
+
+export interface BlobPropertyBag {
+    endings?: EndingType;
+    type?: string;
+}
+
+export interface FilePropertyBag extends BlobPropertyBag {
+    lastModified?: number;
+}
+
+export type FileFromPathOptions = Omit<FilePropertyBag, 'lastModified'>;
+
+const _FormData = FormData;
+type _FormData = FormData;
+export { _FormData as FormData };
+
+const _File = File;
+type _File = File;
+export { _File as File };
+
+const _Blob = Blob;
+type _Blob = Blob;
+export { _Blob as Blob };
+
+export async function getMultipartRequestOptions<T = Record<string, unknown>>(form: FormData, opts: RequestOptions<T>): Promise<RequestOptions<T>> {
+    return {
+        ...opts,
+        body: new MultipartBody(form) as any,
+    };
+}
+
+export function getDefaultAgent(url: string) {
+    return undefined;
+}
+export function fileFromPath() {
+    throw new Error('The `fileFromPath` function is only supported in Node.');
+}
+
+export const isFsReadStream = (value: any) => false;
+
+export declare class Readable {
+    readable: boolean;
+    readonly readableEnded: boolean;
+    readonly readableFlowing: boolean | null;
+    readonly readableHighWaterMark: number;
+    readonly readableLength: number;
+    readonly readableObjectMode: boolean;
+    destroyed: boolean;
+    read(size?: number): any;
+    pause(): this;
+    resume(): this;
+    isPaused(): boolean;
+    destroy(error?: Error): this;
+    [Symbol.asyncIterator](): AsyncIterableIterator<any>;
+}
+
+export declare class FsReadStream extends Readable {
+    path: object; // node type is string | Buffer
+}
+
+const _ReadableStream = ReadableStream;
+type _ReadableStream = ReadableStream;
+export { _ReadableStream as ReadableStream };

package/src/_shims/index.d.ts

@@ -2,7 +2,7 @@
  * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
  */
 import { manual } from './manual-types';
-import * as auto from "./auto/types";
+import * as auto from '@space-df/sdk/_shims/auto/types';
 import { type RequestOptions } from '../core';
 
 type SelectType<Manual, Auto> = unknown extends Manual ? Auto : Manual;

package/src/_shims/index.mjs

@@ -2,6 +2,6 @@
  * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
  */
 import * as shims from './registry.mjs';
-import * as auto from "./auto/runtime";
+import * as auto from '@space-df/sdk/_shims/auto/runtime';
 if (!shims.kind) shims.setShims(auto.getRuntime(), { auto: true });
 export * from './registry.mjs';

package/src/index.ts

@@ -74,6 +74,13 @@ export interface ClientOptions {
      * @default false
      */
     allowMultiOrgs?: boolean;
+
+    /**
+     * By default, use the development environment.
+     *
+     * @default false
+     */
+    development?: boolean;
 }
 
 /**
@@ -104,21 +111,26 @@ export class SpaceDFSDK extends Core.APIClient {
         organization = Core.readEnv('SPACEDF_ORG_ID') ?? null,
         APIKey = Core.readEnv('SPACEDF_API_KEY'),
         allowMultiOrgs = false,
+        development = false,
         ...opts
     }: ClientOptions = {}) {
+        // Determine base URL based on development flag
+        let finalBaseURL = development ? `https://api.myspacedf.net/api` : `https://api.myspacedf.com/api`;
+
         if (!allowMultiOrgs) {
             if (baseURL && organization)
                 throw new Errors.SpaceDFError('`baseURL` will be overridden by `organization`. You should only configure a single property.');
 
             if (organization) {
-                baseURL = `https://${organization}.api.v0.spacedf.net/api`;
+                finalBaseURL = development ? `https://${organization}.api.myspacedf.net/api` : (finalBaseURL = `https://${organization}.api.myspacedf.com/api`);
             }
         }
 
         const options: ClientOptions = {
             organization,
             APIKey,
-            baseURL: baseURL || `https://api.v0.spacedf.net/api`,
+            baseURL: finalBaseURL,
+            development,
             ...opts,
         };
 
@@ -143,9 +155,20 @@ export class SpaceDFSDK extends Core.APIClient {
     spaceRoles: API.SpaceRoles = new API.SpaceRoles(this);
     spaces: API.Spaces = new API.Spaces(this);
     dashboards: API.Dashboards = new API.Dashboards(this);
+    widgets: API.Widgets = new API.Widgets(this);
     deviceStates: API.DeviceStates = new API.DeviceStates(this);
     oauth2: API.OAuth2 = new API.OAuth2(this);
     credentials: API.Credentials = new API.Credentials(this);
+    users: API.Users = new API.Users(this);
+    presignedUrl: API.PresignedUrl = new API.PresignedUrl(this);
+    deviceConnector: API.DeviceConnector = new API.DeviceConnector(this);
+    deviceModel: API.DeviceModel = new API.DeviceModel(this);
+    device: API.Device = new API.Device(this);
+    manufacturers: API.Manufacturers = new API.Manufacturers(this);
+    networkServer: API.NetworkServer = new API.NetworkServer(this);
+    deviceSpaces: API.DeviceSpaces = new API.DeviceSpaces(this);
+    trip: API.Trip = new API.Trip(this);
+    organizations: API.Organizations = new API.Organizations(this);
 
     protected override defaultQuery(): Core.DefaultQuery | undefined {
         return this._options.defaultQuery;
@@ -159,10 +182,11 @@ export class SpaceDFSDK extends Core.APIClient {
     }
 
     protected override authHeaders(opts: Core.FinalRequestOptions): Core.Headers {
-        const Authorization = `Bearer ${(this.allowMultiOrgs && opts.accessToken) || this.accessToken || ''}`;
+        const accessToken = (this.allowMultiOrgs && opts.accessToken) || this.accessToken || '';
+        const Authorization = `Bearer ${accessToken}`;
         const APIKey = (this.allowMultiOrgs && opts.APIKey) || this.APIKey;
 
-        return { Authorization, 'x-api-key': APIKey };
+        return accessToken ? { Authorization, 'x-api-key': APIKey } : { 'x-api-key': APIKey };
     }
 
     public setAccessToken(token: string | null): void {

package/src/resources/auth/auth.ts

@@ -10,6 +10,22 @@ export class Auth extends APIResource {
         return this._client.post(`/auth/oauth2/google`, { body, ...options });
     }
 
+    googleLogin(body: GoogleLogin, options?: Core.RequestOptions): Core.APIPromise<AuthTokenPair> {
+        return this._client.post(`/auth/google/login`, { body, ...options });
+    }
+
+    oauthSendOtp(body: OAuthSendEmail, options?: Core.RequestOptions): Core.APIPromise<OAuthSendEmail> {
+        return this._client.post(`/auth/send-otp`, { body, ...options });
+    }
+
+    forgetPassword(body: ForgetPasswordParams, options?: Core.RequestOptions): Core.APIPromise<ForgetPasswordParams> {
+        return this._client.post(`/auth/forget-password`, { body, ...options });
+    }
+
+    sendEmailConfirm(body: OAuthSendEmail, options?: Core.RequestOptions): Core.APIPromise<OAuthSendEmail> {
+        return this._client.post(`/auth/send-email-confirm`, { body, ...options });
+    }
+
     oauth2SpaceDF(body: OAuthSpaceDF, options?: Core.RequestOptions): Core.APIPromise<OAuthSpaceDF> {
         return this._client.post(`/auth/oauth2/spacedf-console`, { body, ...options });
     }
@@ -25,6 +41,10 @@ export class Auth extends APIResource {
     switchSpaces(body: AuthRefreshTokenParams, options?: Core.RequestOptions): Core.APIPromise<CustomTokenRefresh> {
         return this._client.post(`/auth/spaces/switch`, { body, ...options });
     }
+
+    changePassword(body: AuthChangePasswordParams, options?: Core.RequestOptions): Core.APIPromise<AuthChangePasswordParams> {
+        return this._client.put(`/auth/change-password`, { body, ...options });
+    }
 }
 
 export interface AuthTokenPair {
@@ -49,6 +69,14 @@ export interface OAuthLogin {
     code_verifier: string;
 }
 
+export interface GoogleLogin {
+    authorization_code: string;
+}
+
+export interface OAuthSendEmail {
+    email: string;
+}
+
 export interface OAuthSpaceDF {
     code_verifier: string;
 
@@ -75,10 +103,20 @@ export interface AuthLoginParams {
     password: string;
 }
 
+export interface ForgetPasswordParams {
+    token: string;
+
+    password: string;
+}
+
+export interface AuthChangePasswordParams {
+    password: string;
+
+    new_password: string;
+}
+
 export interface AuthRefreshTokenParams {
     refresh: string;
-
-    space: string;
 }
 
 export interface AuthRegisterParams {
@@ -89,4 +127,6 @@ export interface AuthRegisterParams {
     first_name: string;
 
     last_name: string;
+
+    otp: string;
 }

package/src/resources/auth/index.ts

@@ -4,3 +4,5 @@ export * from './space-policies';
 export * from './space-roles';
 export * from './space-role-users';
 export * from './credentials';
+export * from './users';
+export * from './presigned-url';

package/src/resources/auth/presigned-url.ts

@@ -0,0 +1,13 @@
+import { APIResource } from '../../resource';
+import * as Core from '../../core';
+
+export class PresignedUrl extends APIResource {
+    get(options?: Core.RequestOptions): Core.APIPromise<PresignedUrlResponse> {
+        return this._client.get('/presigned-url', options);
+    }
+}
+
+export interface PresignedUrlResponse {
+    presigned_url: string;
+    file_name: string;
+}

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

@@ -4,17 +4,28 @@ import { ListParamsResponse, ListResponse } from '../../types/api';
 import * as Core from '../../core';
 
 export class SpacePolicies extends APIResource {
-    retrieve(id: number, options?: Core.RequestOptions): Core.APIPromise<SpacePolicy> {
-        return this._client.get(`/space-policies/${id}`, options);
+    retrieve(id: number, params: SpacePolicyParams, options?: Core.RequestOptions): Core.APIPromise<SpacePolicy> {
+        const { 'X-Space': xspace } = params;
+        return this._client.get(`/space-policies/${id}`, {
+            ...options,
+            headers: { ...options?.headers, 'X-Space': xspace },
+        });
     }
 
-    list(query?: SpacePolicyListParams, options?: Core.RequestOptions): Core.APIPromise<SpacePolicyListResponse>;
-    list(options?: Core.RequestOptions): Core.APIPromise<SpacePolicyListResponse>;
-    list(query: SpacePolicyListParams | Core.RequestOptions = {}, options?: Core.RequestOptions): Core.APIPromise<SpacePolicyListResponse> {
+    list(spaceName: string, query?: SpacePolicyListParams, options?: Core.RequestOptions): Core.APIPromise<SpacePolicyListResponse>;
+    list(spaceName: string, options?: Core.RequestOptions): Core.APIPromise<SpacePolicyListResponse>;
+    list(spaceName: string, query: SpacePolicyListParams | Core.RequestOptions = {}, options?: Core.RequestOptions): Core.APIPromise<SpacePolicyListResponse> {
         if (isRequestOptions(query)) {
-            return this.list({}, query);
+            return this.list(spaceName, {}, query);
         }
-        return this._client.get(`/space-policies`, { query, ...options });
+        const mergedOptions: Core.RequestOptions = {
+            ...options,
+            headers: {
+                ...(options?.headers || {}),
+                'X-Space': spaceName,
+            },
+        };
+        return this._client.get(`/space-policies`, { query, ...mergedOptions });
     }
 }
 
@@ -53,3 +64,7 @@ export interface SpacePolicy {
 export type SpacePolicyListResponse = ListResponse<SpacePolicy>;
 
 export type SpacePolicyListParams = ListParamsResponse;
+
+export interface SpacePolicyParams {
+    'X-Space': string;
+}

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

@@ -3,26 +3,54 @@ import { ListParamsResponse, ListResponse } from '../../types/api';
 import * as Core from '../../core';
 
 export class SpaceRoleUsers extends APIResource {
-    retrieve(id: number, options?: Core.RequestOptions): Core.APIPromise<SpaceRoleUser> {
+    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 },
+            headers: { ...options?.headers, 'X-Space': xspace },
         });
     }
 
-    list(params: ListParamsResponse, options?: Core.RequestOptions): Core.APIPromise<SpaceRoleUserListResponse> {
+    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 },
+            headers: { ...options?.headers, 'X-Space': spaceName },
         });
     }
 
-    delete(id: number, options?: Core.RequestOptions): Core.APIPromise<void> {
+    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 },
+            headers: { Accept: '*/*', ...options?.headers, 'X-Space': xspace },
         });
     }
 }
@@ -39,4 +67,13 @@ export interface SpaceRoleUser {
     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/src/resources/auth/space-roles.ts

@@ -4,52 +4,54 @@ import * as Core from '../../core';
 
 export class SpaceRoles extends APIResource {
     create(params: SpaceRoleCreateParams, options?: Core.RequestOptions): Core.APIPromise<SpaceRole> {
-        const { ...body } = params;
+        const { 'X-Space': xspace, ...body } = params;
         return this._client.post(`/space-roles`, {
             body,
             ...options,
-            headers: { ...options?.headers },
+            headers: { ...options?.headers, 'X-Space': xspace },
         });
     }
 
-    retrieve(id: number, options?: Core.RequestOptions): Core.APIPromise<SpaceRole> {
+    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 },
+            headers: { ...options?.headers, 'X-Space': xspace },
         });
     }
 
     update(id: number, params: SpaceRoleUpdateParams, options?: Core.RequestOptions): Core.APIPromise<SpaceRole> {
-        const { ...body } = params;
+        const { 'X-Space': xspace, ...body } = params;
         return this._client.put(`/space-roles/${id}`, {
             body,
             ...options,
-            headers: { ...options?.headers },
+            headers: { ...options?.headers, 'X-Space': xspace },
         });
     }
 
     partialUpdate(id: number, params: SpaceRoleUpdateParams, options?: Core.RequestOptions): Core.APIPromise<SpaceRole> {
-        const { ...body } = params;
+        const { 'X-Space': xspace, ...body } = params;
         return this._client.patch(`/space-roles/${id}`, {
             body,
             ...options,
-            headers: { ...options?.headers },
+            headers: { ...options?.headers, 'X-Space': xspace },
         });
     }
 
-    list(params: ListParamsResponse, options?: Core.RequestOptions): Core.APIPromise<SpaceRoleListResponse> {
+    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 },
+            headers: { ...options?.headers, 'X-Space': spaceName },
         });
     }
 
-    delete(id: number, options?: Core.RequestOptions): Core.APIPromise<void> {
+    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 },
+            headers: { Accept: '*/*', ...options?.headers, 'X-Space': xspace },
         });
     }
 }
@@ -80,6 +82,11 @@ export interface SpaceRoleCreateParams {
      * Body param:
      */
     policies: Array<number>;
+
+    /**
+     * Header param:
+     */
+    'X-Space': string;
 }
 
 export interface SpaceRoleUpdateParams {
@@ -92,4 +99,12 @@ export interface SpaceRoleUpdateParams {
      * Body param:
      */
     policies: Array<number>;
+    /**
+     * Header param:
+     */
+    'X-Space': string;
+}
+
+export interface SpaceRoleParams {
+    'X-Space': string;
 }