@qidcloud/sdk 1.2.3 → 1.2.4

package/dist/index.js

@@ -99,6 +99,138 @@ class AuthModule {
             role: data.role
         };
     }
+    // --- Conventional Auth Methods ---
+    /**
+     * Login using username and password
+     */
+    async login(credentials) {
+        const resp = await this.sdk.api.post('/api/login/conventional', credentials);
+        return resp.data;
+    }
+    /**
+     * Register a new user
+     */
+    async register(data) {
+        const resp = await this.sdk.api.post('/api/register/conventional', data);
+        return resp.data;
+    }
+    /**
+     * Initiate registration (OTP based if configured)
+     */
+    async initiateRegistration(email) {
+        const resp = await this.sdk.api.post('/api/register/initiate', { email });
+        return resp.data;
+    }
+    /**
+     * Verify OTP or mobile verification
+     */
+    async verify(data) {
+        const resp = await this.sdk.api.post('/api/verify', data);
+        return resp.data;
+    }
+    // --- Password & Account Management ---
+    /**
+     * Request a password reset link/OTP
+     */
+    async requestPasswordReset(email) {
+        const resp = await this.sdk.api.post('/api/password/reset/request', { email });
+        return resp.data;
+    }
+    /**
+     * Confirm password reset with OTP and new password
+     */
+    async confirmPasswordReset(data) {
+        const resp = await this.sdk.api.post('/api/password/reset/confirm', data);
+        return resp.data;
+    }
+    /**
+     * Change current password (requires current token)
+     */
+    async changePassword(token, data) {
+        const resp = await this.sdk.api.post('/api/password/change', data, {
+            headers: { 'Authorization': `Bearer ${token}` }
+        });
+        return resp.data;
+    }
+    /**
+     * Delete user account
+     */
+    async deleteAccount(token) {
+        const resp = await this.sdk.api.delete('/api/auth/account', {
+            headers: { 'Authorization': `Bearer ${token}` }
+        });
+        return resp.data;
+    }
+    // --- MFA Management ---
+    /**
+     * Toggle MFA status (Enable/Disable)
+     */
+    async toggleMFA(token, data) {
+        const resp = await this.sdk.api.post('/api/auth/mfa/toggle', data, {
+            headers: { 'Authorization': `Bearer ${token}` }
+        });
+        return resp.data;
+    }
+    /**
+     * Verify MFA toggle request
+     */
+    async verifyMFA(token, otp) {
+        const resp = await this.sdk.api.post('/api/auth/mfa/verify', { otp }, {
+            headers: { 'Authorization': `Bearer ${token}` }
+        });
+        return resp.data;
+    }
+    // --- Session & Recovery ---
+    /**
+     * Refresh the current active session
+     */
+    async refreshSession(token) {
+        const resp = await this.sdk.api.post('/api/session/refresh', {}, {
+            headers: { 'Authorization': `Bearer ${token}` }
+        });
+        return resp.data;
+    }
+    /**
+     * List all active sessions for the user
+     */
+    async getSessions(token) {
+        const resp = await this.sdk.api.get('/api/sessions', {
+            headers: { 'Authorization': `Bearer ${token}` }
+        });
+        return resp.data;
+    }
+    /**
+     * Revoke a specific session
+     */
+    async revokeSession(token, sessionToken) {
+        const resp = await this.sdk.api.delete(`/api/sessions/${sessionToken}`, {
+            headers: { 'Authorization': `Bearer ${token}` }
+        });
+        return resp.data;
+    }
+    /**
+     * Initiate account recovery (password reset)
+     */
+    async initiateRecovery(email) {
+        const resp = await this.sdk.api.post('/api/recover', { email });
+        return resp.data;
+    }
+    /**
+     * Verify recovery OTP and set new password
+     */
+    async verifyRecovery(data) {
+        const resp = await this.sdk.api.post('/api/recover/verify', data);
+        return resp.data;
+    }
+    /**
+     * Export all user data (GDPR requirement)
+     */
+    async exportUserData(token) {
+        const resp = await this.sdk.api.get('/api/auth/account/export', {
+            headers: { 'Authorization': `Bearer ${token}` }
+        });
+        return resp.data;
+    }
 }
 
 class DbModule {
@@ -132,6 +264,98 @@ class DbModule {
         const resp = await this.sdk.api.post('/api/db/setup', {}, { headers });
         return resp.data;
     }
+    /**
+     * Run versioned migrations (Django-inspired).
+     * Only applies migrations that haven't been applied yet.
+     * Tracks applied migrations in a `_qid_migrations` table.
+     *
+     * @example
+     * ```ts
+     * await qid.db.migrate([
+     *   { version: '001', name: 'create_users', up: async () => { await qid.db.query('CREATE TABLE ...') } },
+     *   { version: '002', name: 'add_likes',    up: async () => { await qid.db.query('ALTER TABLE ...') } },
+     * ]);
+     * ```
+     *
+     * @param migrations Ordered array of migrations to apply
+     * @param userToken Optional session token
+     * @returns Result with applied/skipped counts
+     */
+    async migrate(migrations, userToken) {
+        const result = {
+            success: true,
+            applied: [],
+            skipped: [],
+            total: migrations.length,
+        };
+        try {
+            // 1. Ensure the migrations tracking table exists
+            await this.query(`CREATE TABLE IF NOT EXISTS _qid_migrations (
+          version VARCHAR(50) PRIMARY KEY,
+          name VARCHAR(255) NOT NULL,
+          applied_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )`, [], userToken);
+            // 2. Get already-applied migrations
+            const appliedRes = await this.query('SELECT version FROM _qid_migrations ORDER BY version', [], userToken);
+            const appliedVersions = new Set((appliedRes.data || []).map((r) => r.version));
+            // 3. Run only new migrations, in order
+            for (const migration of migrations) {
+                if (appliedVersions.has(migration.version)) {
+                    result.skipped.push(migration.version);
+                    continue;
+                }
+                try {
+                    await migration.up();
+                    // Record as applied
+                    await this.query('INSERT INTO _qid_migrations (version, name) VALUES ($1, $2) ON CONFLICT (version) DO NOTHING', [migration.version, migration.name], userToken);
+                    result.applied.push(migration.version);
+                }
+                catch (migrationError) {
+                    result.success = false;
+                    result.failed = {
+                        version: migration.version,
+                        error: migrationError.message || 'Unknown error',
+                    };
+                    // Stop on first failure (like Django)
+                    break;
+                }
+            }
+            return result;
+        }
+        catch (err) {
+            return {
+                success: false,
+                applied: result.applied,
+                skipped: result.skipped,
+                failed: { version: 'init', error: err.message || 'Migration system init failed' },
+                total: migrations.length,
+            };
+        }
+    }
+    /**
+     * Get the current migration status
+     * @param migrations The full list of registered migrations
+     * @param userToken Optional session token
+     */
+    async migrateStatus(migrations, userToken) {
+        try {
+            const appliedRes = await this.query('SELECT version FROM _qid_migrations ORDER BY version', [], userToken);
+            const appliedVersions = new Set((appliedRes.data || []).map((r) => r.version));
+            return {
+                applied: migrations.filter(m => appliedVersions.has(m.version)).map(m => m.version),
+                pending: migrations.filter(m => !appliedVersions.has(m.version)).map(m => m.version),
+                total: migrations.length,
+            };
+        }
+        catch {
+            // Table doesn't exist yet = all pending
+            return {
+                applied: [],
+                pending: migrations.map(m => m.version),
+                total: migrations.length,
+            };
+        }
+    }
 }
 
 class EdgeModule {
@@ -225,19 +449,38 @@ class EdgeModule {
     }
 }
 
+const DEFAULT_CHUNK_SIZE = 5 * 1024 * 1024; // 5MB
+const CHUNKED_THRESHOLD = 10 * 1024 * 1024; // 10MB — above this, use chunked upload
 class VaultModule {
     sdk;
     constructor(sdk) {
         this.sdk = sdk;
     }
     /**
-     * Upload a file to the project's secure enclave storage
-     * @param file The file data (Buffer or Blob)
+     * Upload a file to the project's secure enclave storage.
+     *
+     * Files < 10MB use single-shot upload.
+     * Files >= 10MB automatically use chunked upload with progress tracking.
+     *
+     * @param file The file data (Buffer, Blob, or File)
      * @param fileName Name of the file
      * @param metadata Optional E2EE metadata or custom tags
      * @param userToken Session token for user-scoped storage
+     * @param options Upload options (onProgress callback, custom chunk size)
      */
-    async upload(file, fileName, metadata = {}, userToken) {
+    async upload(file, fileName, metadata = {}, userToken, options) {
+        const fileSize = file.size || file.length || file.byteLength || 0;
+        // Auto-detect: use chunked upload for large files
+        if (fileSize >= CHUNKED_THRESHOLD) {
+            return this._chunkedUpload(file, fileName, fileSize, metadata, userToken, options);
+        }
+        // Small file — single-shot upload (existing behavior)
+        return this._singleUpload(file, fileName, metadata, userToken);
+    }
+    /**
+     * Single-shot upload for small files (< 10MB)
+     */
+    async _singleUpload(file, fileName, metadata, userToken) {
         const formData = new FormData();
         formData.append('file', file, fileName);
         formData.append('metadata', JSON.stringify(metadata));
@@ -250,9 +493,149 @@ class VaultModule {
         const resp = await this.sdk.api.post('/api/storage/upload', formData, { headers });
         return resp.data;
     }
+    /**
+     * Chunked upload for large files (>= 10MB)
+     * Flow: init → upload chunks → complete
+     */
+    async _chunkedUpload(file, fileName, fileSize, metadata, userToken, options) {
+        const chunkSize = options?.chunkSize || DEFAULT_CHUNK_SIZE;
+        const totalChunks = Math.ceil(fileSize / chunkSize);
+        const onProgress = options?.onProgress;
+        const headers = {};
+        if (userToken) {
+            headers['Authorization'] = `Bearer ${userToken}`;
+        }
+        // 1. Initialize upload session
+        const initResp = await this.sdk.api.post('/api/storage/upload/init', {
+            fileName,
+            fileSize,
+            mimeType: file.type || 'application/octet-stream',
+            totalChunks,
+            metadata
+        }, { headers });
+        const { uploadId } = initResp.data;
+        let uploadedChunks = 0;
+        // 2. Upload chunks sequentially
+        for (let i = 0; i < totalChunks; i++) {
+            const start = i * chunkSize;
+            const end = Math.min(start + chunkSize, fileSize);
+            // Slice the chunk from the file
+            let chunkData;
+            if (file.slice) {
+                // Blob or File object
+                chunkData = file.slice(start, end);
+            }
+            else if (file.subarray) {
+                // Buffer or Uint8Array
+                chunkData = file.subarray(start, end);
+            }
+            else if (typeof file === 'object' && file.data) {
+                // express-fileupload style
+                chunkData = file.data.subarray(start, end);
+            }
+            // Build FormData for this chunk
+            const chunkForm = new FormData();
+            const chunkBlob = chunkData instanceof Blob ? chunkData : new Blob([chunkData]);
+            chunkForm.append('chunk', chunkBlob, `chunk_${i}`);
+            await this.sdk.api.put(`/api/storage/upload/${uploadId}/chunk/${i}`, chunkForm, {
+                headers: {
+                    ...headers,
+                    'Content-Type': 'multipart/form-data'
+                }
+            });
+            uploadedChunks++;
+            // Report progress
+            if (onProgress) {
+                onProgress({
+                    percent: Math.round((uploadedChunks / totalChunks) * 100),
+                    uploadedChunks,
+                    totalChunks,
+                    uploadedBytes: Math.min(uploadedChunks * chunkSize, fileSize),
+                    totalBytes: fileSize
+                });
+            }
+        }
+        // 3. Complete upload — server reassembles, encrypts, stores
+        const completeResp = await this.sdk.api.post(`/api/storage/upload/${uploadId}/complete`, { metadata }, { headers });
+        // Final 100% progress
+        if (onProgress) {
+            onProgress({
+                percent: 100,
+                uploadedChunks: totalChunks,
+                totalChunks,
+                uploadedBytes: fileSize,
+                totalBytes: fileSize
+            });
+        }
+        return completeResp.data;
+    }
+    /**
+     * Get the status of a chunked upload (for resume support)
+     */
+    async getUploadStatus(uploadId, userToken) {
+        const headers = {};
+        if (userToken) {
+            headers['Authorization'] = `Bearer ${userToken}`;
+        }
+        const resp = await this.sdk.api.get(`/api/storage/upload/${uploadId}/status`, { headers });
+        return resp.data;
+    }
+    /**
+     * Resume a partially completed chunked upload
+     */
+    async resumeUpload(uploadId, file, userToken, options) {
+        const headers = {};
+        if (userToken) {
+            headers['Authorization'] = `Bearer ${userToken}`;
+        }
+        // Get current status to find missing chunks
+        const status = await this.getUploadStatus(uploadId, userToken);
+        if (status.status !== 'uploading') {
+            throw new Error(`Upload is in "${status.status}" state and cannot be resumed`);
+        }
+        const chunkSize = options?.chunkSize || status.chunkSize || DEFAULT_CHUNK_SIZE;
+        const onProgress = options?.onProgress;
+        const missingChunks = status.missingChunks;
+        const totalChunks = status.totalChunks;
+        const fileSize = status.fileSize;
+        let uploadedChunks = status.receivedChunks.length;
+        // Upload only the missing chunks
+        for (const i of missingChunks) {
+            const start = i * chunkSize;
+            const end = Math.min(start + chunkSize, fileSize);
+            let chunkData;
+            if (file.slice) {
+                chunkData = file.slice(start, end);
+            }
+            else if (file.subarray) {
+                chunkData = file.subarray(start, end);
+            }
+            const chunkForm = new FormData();
+            const chunkBlob = chunkData instanceof Blob ? chunkData : new Blob([chunkData]);
+            chunkForm.append('chunk', chunkBlob, `chunk_${i}`);
+            await this.sdk.api.put(`/api/storage/upload/${uploadId}/chunk/${i}`, chunkForm, {
+                headers: {
+                    ...headers,
+                    'Content-Type': 'multipart/form-data'
+                }
+            });
+            uploadedChunks++;
+            if (onProgress) {
+                onProgress({
+                    percent: Math.round((uploadedChunks / totalChunks) * 100),
+                    uploadedChunks,
+                    totalChunks,
+                    uploadedBytes: Math.min(uploadedChunks * chunkSize, fileSize),
+                    totalBytes: fileSize
+                });
+            }
+        }
+        // Complete
+        const completeResp = await this.sdk.api.post(`/api/storage/upload/${uploadId}/complete`, {}, { headers });
+        return completeResp.data;
+    }
     /**
      * List files in the project enclave
-     * @param userToken Session token for user-scoped storage
      */
     async list(userToken) {
         const headers = {};
@@ -264,8 +647,6 @@ class VaultModule {
     }
     /**
      * Download a file from storage
-     * @param fileId Unique ID of the file
-     * @param userToken Session token for user-scoped storage
      */
     async download(fileId, userToken) {
         const headers = {};
@@ -280,8 +661,6 @@ class VaultModule {
     }
     /**
      * Delete a file from storage (Soft Delete)
-     * @param fileId Unique ID of the file
-     * @param userToken Session token for user-scoped storage
      */
     async delete(fileId, userToken) {
         const headers = {};
@@ -293,7 +672,6 @@ class VaultModule {
     }
     /**
      * List deleted files in the project enclave (Recycle Bin)
-     * @param userToken Session token for user-scoped storage
      */
     async listDeleted(userToken) {
         const headers = {};
@@ -305,8 +683,6 @@ class VaultModule {
     }
     /**
      * Restore a deleted file from the recycle bin
-     * @param fileId Unique ID of the file
-     * @param userToken Session token for user-scoped storage
      */
     async restore(fileId, userToken) {
         const headers = {};
@@ -318,8 +694,6 @@ class VaultModule {
     }
     /**
      * Permanently purge a deleted file
-     * @param fileId Unique ID of the file
-     * @param userToken Session token for user-scoped storage
      */
     async purge(fileId, userToken) {
         const headers = {};
@@ -357,6 +731,341 @@ class LogsModule {
     }
 }
 
+class ProjectModule {
+    sdk;
+    constructor(sdk) {
+        this.sdk = sdk;
+    }
+    /**
+     * Get all projects owned by the currently authenticated user
+     */
+    async getMyProjects(userToken) {
+        const resp = await this.sdk.api.get('/api/projects/my-projects', {
+            headers: { 'Authorization': `Bearer ${userToken}` }
+        });
+        return resp.data;
+    }
+    /**
+     * Create a new project
+     */
+    async createProject(userToken, data) {
+        const resp = await this.sdk.api.post('/api/projects', data, {
+            headers: { 'Authorization': `Bearer ${userToken}` }
+        });
+        return resp.data;
+    }
+    /**
+     * Update project basic details (e.g. rename)
+     */
+    async updateProject(userToken, tenantId, data) {
+        const resp = await this.sdk.api.patch(`/api/projects/${tenantId}`, data, {
+            headers: { 'Authorization': `Bearer ${userToken}` }
+        });
+        return resp.data;
+    }
+    /**
+     * Rotate the API key for a project
+     */
+    async rotateApiKey(userToken, tenantId) {
+        const resp = await this.sdk.api.post(`/api/projects/${tenantId}/rotate-key`, {}, {
+            headers: { 'Authorization': `Bearer ${userToken}` }
+        });
+        return resp.data;
+    }
+    /**
+     * Get project specific settings
+     */
+    async getSettings(userToken, tenantId) {
+        const resp = await this.sdk.api.get(`/api/projects/${tenantId}/settings`, {
+            headers: { 'Authorization': `Bearer ${userToken}` }
+        });
+        return resp.data;
+    }
+    /**
+     * Update project settings
+     */
+    async updateSettings(userToken, tenantId, settings) {
+        const resp = await this.sdk.api.patch(`/api/projects/${tenantId}/settings`, settings, {
+            headers: { 'Authorization': `Bearer ${userToken}` }
+        });
+        return resp.data;
+    }
+    /**
+     * Invite a new member to the project
+     */
+    async inviteMember(userToken, tenantId, data) {
+        const resp = await this.sdk.api.post(`/api/projects/${tenantId}/invite`, data, {
+            headers: { 'Authorization': `Bearer ${userToken}` }
+        });
+        return resp.data;
+    }
+    /**
+     * Remove a member from the project
+     */
+    async removeMember(userToken, tenantId, userId) {
+        const resp = await this.sdk.api.delete(`/api/projects/${tenantId}/members/${userId}`, {
+            headers: { 'Authorization': `Bearer ${userToken}` }
+        });
+        return resp.data;
+    }
+    /**
+     * Get all users/members associated with a project
+     */
+    async getProjectUsers(userToken, tenantId) {
+        const resp = await this.sdk.api.get(`/api/projects/${tenantId}/users`, {
+            headers: { 'Authorization': `Bearer ${userToken}` }
+        });
+        return resp.data;
+    }
+    /**
+     * Get all invitations for the currently authenticated user
+     */
+    async getMyInvitations(userToken) {
+        const resp = await this.sdk.api.get('/api/projects/invitations', {
+            headers: { 'Authorization': `Bearer ${userToken}` }
+        });
+        return resp.data;
+    }
+    /**
+     * Accept or reject a project invitation
+     */
+    async handleInvitationAction(userToken, tenantId, action) {
+        const resp = await this.sdk.api.post(`/api/projects/${tenantId}/invitations/${action}`, {}, {
+            headers: { 'Authorization': `Bearer ${userToken}` }
+        });
+        return resp.data;
+    }
+    /**
+     * Update a member's permissions within a project
+     */
+    async updateMemberPermissions(userToken, tenantId, userId, permissions) {
+        const resp = await this.sdk.api.patch(`/api/projects/${tenantId}/members/${userId}/permissions`, { permissions }, {
+            headers: { 'Authorization': `Bearer ${userToken}` }
+        });
+        return resp.data;
+    }
+    /**
+     * Update a project user's status (active/suspended)
+     */
+    async updateProjectUserStatus(userToken, tenantId, regUserId, status) {
+        const resp = await this.sdk.api.patch(`/api/projects/${tenantId}/users/${regUserId}/status`, { status }, {
+            headers: { 'Authorization': `Bearer ${userToken}` }
+        });
+        return resp.data;
+    }
+    /**
+     * Unlink/Remove a user from the project identity enclave
+     */
+    async unlinkProjectUser(userToken, tenantId, regUserId) {
+        const resp = await this.sdk.api.delete(`/api/projects/${tenantId}/users/${regUserId}`, {
+            headers: { 'Authorization': `Bearer ${userToken}` }
+        });
+        return resp.data;
+    }
+    /**
+     * Generate a new service key for the project
+     */
+    async generateServiceKey(userToken, tenantId, data) {
+        const resp = await this.sdk.api.post(`/api/projects/${tenantId}/service-keys`, data, {
+            headers: { 'Authorization': `Bearer ${userToken}` }
+        });
+        return resp.data;
+    }
+    /**
+     * Revoke an existing service key
+     */
+    async revokeServiceKey(userToken, tenantId, keyId) {
+        const resp = await this.sdk.api.delete(`/api/projects/${tenantId}/service-keys/${keyId}`, {
+            headers: { 'Authorization': `Bearer ${userToken}` }
+        });
+        return resp.data;
+    }
+    /**
+     * Permanently wipe the project's identity enclave data
+     */
+    async wipeProjectEnclave(userToken, tenantId) {
+        const resp = await this.sdk.api.post(`/api/projects/${tenantId}/wipe`, {}, {
+            headers: { 'Authorization': `Bearer ${userToken}` }
+        });
+        return resp.data;
+    }
+    /**
+     * Retrieve security and audit logs for the project
+     */
+    async getProjectSecurityLogs(userToken, tenantId) {
+        const resp = await this.sdk.api.get(`/api/projects/${tenantId}/logs`, {
+            headers: { 'Authorization': `Bearer ${userToken}` }
+        });
+        return resp.data;
+    }
+}
+
+class ResourceModule {
+    sdk;
+    constructor(sdk) {
+        this.sdk = sdk;
+    }
+    /**
+     * Get the status of all resources for a specific tenant
+     */
+    async getStatus(userToken, tenantId) {
+        const resp = await this.sdk.api.get(`/api/resources/${tenantId}`, {
+            headers: { 'Authorization': `Bearer ${userToken}` }
+        });
+        return resp.data;
+    }
+    /**
+     * Provision a new resource type for a project
+     * @param resourceType 'database' | 'storage' | 'edge'
+     */
+    async provision(userToken, tenantId, resourceType) {
+        const resp = await this.sdk.api.post(`/api/resources/${tenantId}/provision/${resourceType}`, {}, {
+            headers: { 'Authorization': `Bearer ${userToken}` }
+        });
+        return resp.data;
+    }
+    /**
+     * Dissolve (delete) an existing resource from a project
+     */
+    async dissolve(userToken, tenantId, resourceType) {
+        const resp = await this.sdk.api.delete(`/api/resources/${tenantId}/provision/${resourceType}`, {
+            headers: { 'Authorization': `Bearer ${userToken}` }
+        });
+        return resp.data;
+    }
+}
+
+class SdkModule {
+    sdk;
+    constructor(sdk) {
+        this.sdk = sdk;
+    }
+    /**
+     * Get allowed origins for a project
+     */
+    async getOrigins(userToken, tenantId) {
+        const resp = await this.sdk.api.get(`/api/sdk/${tenantId}/origins`, {
+            headers: { 'Authorization': `Bearer ${userToken}` }
+        });
+        return resp.data;
+    }
+    /**
+     * Add an allowed origin for SDK requests
+     */
+    async addOrigin(userToken, tenantId, domain) {
+        const resp = await this.sdk.api.post(`/api/sdk/${tenantId}/origins`, { domain }, {
+            headers: { 'Authorization': `Bearer ${userToken}` }
+        });
+        return resp.data;
+    }
+    /**
+     * Remove an allowed origin
+     */
+    async removeOrigin(userToken, tenantId, domain) {
+        const resp = await this.sdk.api.delete(`/api/sdk/${tenantId}/origins/${domain}`, {
+            headers: { 'Authorization': `Bearer ${userToken}` }
+        });
+        return resp.data;
+    }
+    /**
+     * Test if an origin is allowed
+     */
+    async testOrigin(userToken, tenantId, domain) {
+        const resp = await this.sdk.api.post(`/api/sdk/${tenantId}/origins/test`, { domain }, {
+            headers: { 'Authorization': `Bearer ${userToken}` }
+        });
+        return resp.data;
+    }
+}
+
+class BillingModule {
+    sdk;
+    constructor(sdk) {
+        this.sdk = sdk;
+    }
+    /**
+     * Retrieve all available plans and their pricing
+     */
+    async getPlans() {
+        const resp = await this.sdk.api.get('/api/billing/plans');
+        return resp.data;
+    }
+    /**
+     * Get detailed billing and usage info for a project
+     */
+    async getProjectBillingInfo(userToken, tenantId) {
+        const resp = await this.sdk.api.get(`/api/billing/${tenantId}`, {
+            headers: { 'Authorization': `Bearer ${userToken}` }
+        });
+        return resp.data;
+    }
+    /**
+     * Sync payment status after a successful Razorpay transaction
+     * @param paymentId The Razorpay payment ID
+     */
+    async syncPaymentStatus(userToken, paymentId) {
+        const resp = await this.sdk.api.post('/api/billing/sync', { paymentId }, {
+            headers: { 'Authorization': `Bearer ${userToken}` }
+        });
+        return resp.data;
+    }
+    /**
+     * Get transaction history for the current user
+     */
+    async getTransactions(userToken) {
+        const resp = await this.sdk.api.get('/api/billing/history/transactions', {
+            headers: { 'Authorization': `Bearer ${userToken}` }
+        });
+        return resp.data;
+    }
+    /**
+     * Get usage analytics and history
+     */
+    async getUsageAnalytics(userToken) {
+        const resp = await this.sdk.api.get('/api/billing/history/analytics', {
+            headers: { 'Authorization': `Bearer ${userToken}` }
+        });
+        return resp.data;
+    }
+    /**
+     * Get billing alerts for a specific project
+     */
+    async getBillingAlerts(userToken, tenantId) {
+        const resp = await this.sdk.api.get(`/api/billing/${tenantId}/alerts`, {
+            headers: { 'Authorization': `Bearer ${userToken}` }
+        });
+        return resp.data;
+    }
+    /**
+     * Create or update a billing alert
+     */
+    async createBillingAlert(userToken, tenantId, data) {
+        const resp = await this.sdk.api.post(`/api/billing/${tenantId}/alerts`, data, {
+            headers: { 'Authorization': `Bearer ${userToken}` }
+        });
+        return resp.data;
+    }
+    /**
+     * Delete a billing alert
+     */
+    async deleteBillingAlert(userToken, alertId) {
+        const resp = await this.sdk.api.delete(`/api/billing/alerts/${alertId}`, {
+            headers: { 'Authorization': `Bearer ${userToken}` }
+        });
+        return resp.data;
+    }
+    /**
+     * Generate a consolidated financial report
+     */
+    async getConsolidatedReport(userToken, query) {
+        const resp = await this.sdk.api.get('/api/billing/report/consolidated', {
+            params: query,
+            headers: { 'Authorization': `Bearer ${userToken}` }
+        });
+        return resp.data;
+    }
+}
+
 /**
  * A React hook for managing QidCloud authentication lifecycle.
  * Handles handshake initialization, WebSocket listeners, and profile fetching.
@@ -705,6 +1414,10 @@ class QidCloud {
     edge;
     vault;
     logs;
+    projects;
+    resources;
+    sdk;
+    billing;
     constructor(config) {
         this.config = {
             baseUrl: 'https://api.qidcloud.com',
@@ -722,6 +1435,10 @@ class QidCloud {
         this.edge = new EdgeModule(this);
         this.vault = new VaultModule(this);
         this.logs = new LogsModule(this);
+        this.projects = new ProjectModule(this);
+        this.resources = new ResourceModule(this);
+        this.sdk = new SdkModule(this);
+        this.billing = new BillingModule(this);
     }
     /**
      * Get the current project configuration