@datalayer/core 0.0.20 → 0.0.21

package/lib/client/auth/storage.js

@@ -114,12 +114,18 @@ export class NodeStorage {
         this.serviceUrl = serviceUrl;
         try {
             // Load keytar for system keyring access
-            // VS Code extensions get this from VS Code's bundled keytar
-            // CLI gets this from installed keytar package
-            this.keytar = require('keytar');
+            // VS Code bundles keytar, but require path may vary
+            // Try multiple possible paths for compatibility
+            try {
+                this.keytar = require('keytar');
+            }
+            catch {
+                // Try alternate path for VS Code bundled keytar
+                this.keytar = require('@vscode/keytar');
+            }
         }
         catch (e) {
-            // Keyring not available, use memory only
+            // Keyring not available, tokens will not persist across sessions
             console.warn('keytar not available, tokens will not persist');
         }
     }
@@ -128,181 +134,137 @@ export class NodeStorage {
      * Supports both sync (getPasswordSync) and async (getPassword) keytar APIs
      */
     get(key) {
-        console.log('[NodeStorage.get] key:', key, 'keytar available:', !!this.keytar);
         // 1. Try keyring first (if available)
         if (this.keytar) {
             try {
                 // Try sync API first (CLI keytar)
                 if (this.keytar.getPasswordSync) {
-                    console.log('[NodeStorage.get] using keytar.getPasswordSync');
                     const value = this.keytar.getPasswordSync(this.serviceUrl, key);
-                    console.log('[NodeStorage.get] keytar returned:', value ? 'token found' : 'null');
                     if (value)
                         return value;
                 }
-                else {
-                    console.log('[NodeStorage.get] getPasswordSync not available, skipping sync keytar');
-                }
             }
             catch (e) {
-                console.warn('[NodeStorage.get] keytar.getPasswordSync failed:', e);
                 // Fall through to other methods
             }
         }
         // 2. Try environment variables
         const envValue = process.env[key];
-        console.log('[NodeStorage.get] env var', key, ':', envValue ? 'found' : 'not found');
         if (envValue)
             return envValue;
         // 3. Fall back to memory storage
-        const memValue = this.memoryStorage.get(key) || null;
-        console.log('[NodeStorage.get] memory storage:', memValue ? 'found' : 'not found');
-        return memValue;
+        return this.memoryStorage.get(key) || null;
     }
     /**
      * Set token in keyring or memory storage (sync version)
      */
     set(key, value) {
-        console.log('[NodeStorage.set] key:', key, 'keytar available:', !!this.keytar);
         // Store in keyring if available and has sync API
         if (this.keytar && this.keytar.setPasswordSync) {
             try {
-                console.log('[NodeStorage.set] calling keytar.setPasswordSync');
                 this.keytar.setPasswordSync(this.serviceUrl, key, value);
-                console.log('[NodeStorage.set] keytar.setPasswordSync succeeded');
                 return;
             }
             catch (e) {
-                console.warn('[NodeStorage.set] Failed to store in keyring, using memory:', e);
+                // Fall through to memory storage
             }
         }
-        else if (this.keytar) {
-            console.log('[NodeStorage.set] setPasswordSync not available, use setAsync() instead');
-        }
         // Fall back to memory
-        console.log('[NodeStorage.set] falling back to memory storage');
         this.memoryStorage.set(key, value);
     }
     /**
      * Async version of set - supports VS Code's async keytar API
      */
     async setAsync(key, value) {
-        console.log('[NodeStorage.setAsync] key:', key, 'keytar available:', !!this.keytar);
         // Store in keyring if available
         if (this.keytar) {
             try {
                 // Try async API (VS Code keytar)
                 if (this.keytar.setPassword) {
-                    console.log('[NodeStorage.setAsync] calling keytar.setPassword (async)');
                     await this.keytar.setPassword(this.serviceUrl, key, value);
-                    console.log('[NodeStorage.setAsync] keytar.setPassword succeeded');
                     // IMPORTANT: Also store in memory so synchronous get() can access it
                     this.memoryStorage.set(key, value);
                     return;
                 }
                 // Try sync API (CLI keytar)
                 else if (this.keytar.setPasswordSync) {
-                    console.log('[NodeStorage.setAsync] calling keytar.setPasswordSync');
                     this.keytar.setPasswordSync(this.serviceUrl, key, value);
-                    console.log('[NodeStorage.setAsync] keytar.setPasswordSync succeeded');
                     // Also store in memory for consistency
                     this.memoryStorage.set(key, value);
                     return;
                 }
             }
             catch (e) {
-                console.warn('[NodeStorage.setAsync] Failed to store in keyring, using memory:', e);
+                // Fall through to memory storage
             }
         }
         // Fall back to memory
-        console.log('[NodeStorage.setAsync] falling back to memory storage');
         this.memoryStorage.set(key, value);
     }
     /**
      * Async version of get - supports VS Code's async keytar API
      */
     async getAsync(key) {
-        console.log('[NodeStorage.getAsync] key:', key, 'keytar available:', !!this.keytar);
         // Try keyring first (if available)
         if (this.keytar) {
             try {
                 // Try async API (VS Code keytar)
                 if (this.keytar.getPassword) {
-                    console.log('[NodeStorage.getAsync] calling keytar.getPassword (async)');
                     const value = await this.keytar.getPassword(this.serviceUrl, key);
-                    console.log('[NodeStorage.getAsync] keytar returned:', value ? 'token found' : 'null');
                     if (value)
                         return value;
                 }
                 // Try sync API (CLI keytar)
                 else if (this.keytar.getPasswordSync) {
-                    console.log('[NodeStorage.getAsync] calling keytar.getPasswordSync');
                     const value = this.keytar.getPasswordSync(this.serviceUrl, key);
-                    console.log('[NodeStorage.getAsync] keytar returned:', value ? 'token found' : 'null');
                     if (value)
                         return value;
                 }
             }
             catch (e) {
-                console.warn('[NodeStorage.getAsync] keytar failed:', e);
+                // Fall through to other methods
             }
         }
         // Try environment variables
         const envValue = process.env[key];
-        console.log('[NodeStorage.getAsync] env var', key, ':', envValue ? 'found' : 'not found');
         if (envValue)
             return envValue;
         // Fall back to memory storage
-        const memValue = this.memoryStorage.get(key) || null;
-        console.log('[NodeStorage.getAsync] memory storage:', memValue ? 'found' : 'not found');
-        return memValue;
+        return this.memoryStorage.get(key) || null;
     }
     /**
      * Delete token from keyring or memory storage (sync version)
      */
     delete(key) {
-        console.log('[NodeStorage.delete] key:', key, 'keytar available:', !!this.keytar);
         if (this.keytar && this.keytar.deletePasswordSync) {
             try {
-                console.log('[NodeStorage.delete] calling keytar.deletePasswordSync');
                 this.keytar.deletePasswordSync(this.serviceUrl, key);
-                console.log('[NodeStorage.delete] keytar.deletePasswordSync succeeded');
             }
             catch (e) {
-                console.warn('[NodeStorage.delete] Failed to delete from keyring:', e);
+                // Fall through to memory deletion
             }
         }
-        else if (this.keytar) {
-            console.log('[NodeStorage.delete] deletePasswordSync not available, use deleteAsync() instead');
-        }
-        console.log('[NodeStorage.delete] deleting from memory storage');
         this.memoryStorage.delete(key);
     }
     /**
      * Async version of delete - supports VS Code's async keytar API
      */
     async deleteAsync(key) {
-        console.log('[NodeStorage.deleteAsync] key:', key, 'keytar available:', !!this.keytar);
         if (this.keytar) {
             try {
                 // Try async API (VS Code keytar)
                 if (this.keytar.deletePassword) {
-                    console.log('[NodeStorage.deleteAsync] calling keytar.deletePassword (async)');
                     await this.keytar.deletePassword(this.serviceUrl, key);
-                    console.log('[NodeStorage.deleteAsync] keytar.deletePassword succeeded');
                 }
                 // Try sync API (CLI keytar)
                 else if (this.keytar.deletePasswordSync) {
-                    console.log('[NodeStorage.deleteAsync] calling keytar.deletePasswordSync');
                     this.keytar.deletePasswordSync(this.serviceUrl, key);
-                    console.log('[NodeStorage.deleteAsync] keytar.deletePasswordSync succeeded');
                 }
             }
             catch (e) {
-                console.warn('[NodeStorage.deleteAsync] Failed to delete from keyring:', e);
+                // Fall through to memory deletion
             }
         }
-        console.log('[NodeStorage.deleteAsync] deleting from memory storage');
         this.memoryStorage.delete(key);
     }
     /**
@@ -339,29 +301,22 @@ export class NodeStorage {
      * Store authentication token (async version - use this in auth strategies)
      */
     async setToken(token) {
-        console.log('[NodeStorage] setToken called, keytar available:', !!this.keytar);
-        console.log('[NodeStorage] storing token with key: access_token, service:', this.serviceUrl);
         // Use async method to support VS Code's keytar
         await this.setAsync('access_token', token);
-        console.log('[NodeStorage] token stored successfully');
     }
     /**
      * Delete authentication token (async version - use this in auth manager)
      */
     async deleteToken() {
-        console.log('[NodeStorage] deleteToken called');
         // Use async method to support VS Code's keytar
         await this.deleteAsync('access_token');
-        console.log('[NodeStorage] token deleted successfully');
     }
     /**
      * Clear all authentication data (async version - use this in auth manager)
      */
     async clear() {
-        console.log('[NodeStorage] clear called');
         await this.deleteToken();
         this.memoryStorage.clear();
-        console.log('[NodeStorage] all data cleared');
     }
 }
 /**

package/lib/client/base.d.ts

@@ -1,5 +1,6 @@
 import { EnvironmentDTO } from '../models/EnvironmentDTO';
 import { AuthenticationManager } from './auth';
+import type { TokenStorage } from './auth/types';
 /** Handlers for SDK method lifecycle events. */
 export interface SDKHandlers {
     /** Called before any SDK method execution */
@@ -19,6 +20,8 @@ export interface DatalayerClientConfig {
     runtimesRunUrl?: string;
     /** URL for the Spacer service */
     spacerRunUrl?: string;
+    /** Custom token storage backend (optional, defaults to auto-detected) */
+    storage?: TokenStorage;
     /** Handlers for intercepting SDK method calls */
     handlers?: SDKHandlers;
 }

package/lib/client/base.js

@@ -35,8 +35,8 @@ export class DatalayerClientBase {
         this.spacerRunUrl = config.spacerRunUrl || DEFAULT_SERVICE_URLS.SPACER;
         this.token = config.token;
         this.handlers = config.handlers;
-        // Initialize authentication manager
-        this.auth = new AuthenticationManager(this.iamRunUrl);
+        // Initialize authentication manager with custom storage if provided
+        this.auth = new AuthenticationManager(this.iamRunUrl, config.storage);
         // If a token was provided, store it in the auth manager
         if (this.token) {
             this.auth.storeToken(this.token);

package/lib/client/index.d.ts

@@ -24,6 +24,10 @@ import type { SpaceDTO } from '../models/SpaceDTO';
 import type { NotebookDTO } from '../models/NotebookDTO';
 import type { LexicalDTO } from '../models/LexicalDTO';
 import type { HealthCheck } from '../models/HealthCheck';
+import type { SecretDTO } from '../models/Secret';
+import type { CreateSecretRequest, UpdateSecretRequest } from '../models/Secret';
+import type { DatasourceDTO } from '../models/Datasource';
+import type { CreateDatasourceRequest, UpdateDatasourceRequest } from '../models/Datasource';
 declare const DatalayerClientWithMixins: typeof DatalayerClientBase;
 /**
  * Main Datalayer Client providing unified access to all platform services.
@@ -53,19 +57,84 @@ export declare class DatalayerClient extends DatalayerClientWithMixins {
 export type { DatalayerClientConfig, SDKHandlers };
 export { DatalayerClientBase };
 export { UserDTO as User } from './../models/UserDTO';
-export type { UserJSON } from './../models/UserDTO';
+export type { UserJSON, UserData } from './../models/UserDTO';
 export { RuntimeDTO as Runtime } from '../models/RuntimeDTO';
-export type { RuntimeJSON } from '../models/RuntimeDTO';
+export type { RuntimeJSON, RuntimeData, CreateRuntimeRequest, CreateRuntimeResponse, ListRuntimesResponse, } from '../models/RuntimeDTO';
 export { EnvironmentDTO as Environment } from '../models/EnvironmentDTO';
-export type { EnvironmentJSON } from '../models/EnvironmentDTO';
+export type { EnvironmentJSON, EnvironmentData, ListEnvironmentsResponse, } from '../models/EnvironmentDTO';
 export { RuntimeSnapshotDTO as Snapshot } from '../models/RuntimeSnapshotDTO';
+export type { RuntimeSnapshotJSON, RuntimeSnapshotData, CreateRuntimeSnapshotRequest, CreateRuntimeSnapshotResponse, GetRuntimeSnapshotResponse, ListRuntimeSnapshotsResponse, } from '../models/RuntimeSnapshotDTO';
 export { SpaceDTO as Space } from '../models/SpaceDTO';
+export type { SpaceJSON, SpaceData, SpaceItem, CreateSpaceRequest, CreateSpaceResponse, SpacesForUserResponse, CollaborationSessionResponse, DeleteSpaceItemResponse, GetSpaceItemResponse, GetSpaceItemsResponse, CreateNotebookRequest, CreateNotebookResponse, GetNotebookResponse, UpdateNotebookRequest, UpdateNotebookResponse, } from '../models/SpaceDTO';
 export { NotebookDTO as Notebook } from '../models/NotebookDTO';
+export type { NotebookJSON, NotebookData } from '../models/NotebookDTO';
 export { LexicalDTO } from '../models/LexicalDTO';
+export type { LexicalJSON, LexicalData, CreateLexicalRequest, CreateLexicalResponse, GetLexicalResponse, UpdateLexicalRequest, UpdateLexicalResponse, } from '../models/LexicalDTO';
 export { CreditsDTO as Credits } from '../models/CreditsDTO';
+export type { CreditsInfo, CreditReservation, CreditsResponse, } from '../models/CreditsDTO';
 export { ItemDTO as Item } from '../models/ItemDTO';
 export { HealthCheck } from '../models/HealthCheck';
 export type { HealthCheckJSON } from '../models/HealthCheck';
+export { SecretDTO as Secret } from './../models/Secret';
+export type { SecretJSON, SecretData, CreateSecretRequest, UpdateSecretRequest, CreateSecretResponse, GetSecretResponse, ListSecretsResponse, UpdateSecretResponse, DeleteSecretResponse, } from './../models/Secret';
+export { DatasourceDTO as Datasource } from './../models/Datasource';
+export type { DatasourceJSON, DatasourceData, DatasourceType, CreateDatasourceRequest, UpdateDatasourceRequest, CreateDatasourceResponse, GetDatasourceResponse, ListDatasourcesResponse, UpdateDatasourceResponse, } from './../models/Datasource';
+export type { LoginRequest, LoginResponse, UserMeResponse, MembershipsResponse, WhoAmIResponse, } from '../models/IAM';
+export type { HealthzPingResponse } from '../models/Common';
+export { AuthenticationManager } from './auth/AuthenticationManager';
+export type { IUser, IBaseUser } from '../models/User';
+export type { ICell } from '../models/Cell';
+export type { IDatasource, IDatasourceVariant } from '../models/Datasource';
+export type { ICredits, ICreditsReservation } from '../models/Credits';
+export type { ISpaceItem } from '../models/SpaceItem';
+export type { ISurvey } from '../models/Survey';
+export type { ISpace, IBaseSpace, IAnySpace, ISpaceVariant, } from '../models/Space';
+export type { IBaseTeam, IAnyTeam } from '../models/Team';
+export type { IOrganization, IAnyOrganization, IBaseOrganization, } from '../models/Organization';
+export type { IRuntimeModel, IRuntimePod, IRuntimeType, IRuntimeLocation, IRuntimeCapabilities, } from '../models/Runtime';
+export type { IRuntimeSnapshot } from '../models/RuntimeSnapshot';
+export type { IDatalayerEnvironment, IResources, ISnippet, } from '../models/Environment';
+export type { IRole } from '../models/Role';
+export type { IAssignment } from '../models/Assignment';
+export type { IContact } from '../models/Contact';
+export type { ICourse } from '../models/Course';
+export type { IOrganizationMember } from '../models/OrganizationMember';
+export type { IPage, PageTheme, PageVariant } from '../models/Page';
+export type { PageTagName } from '../models/PageTag';
+export type { ISecret, ISecretVariant } from '../models/Secret';
+export type { IIAMToken, IIAMTokenVariant } from '../models/IAMToken';
+export type { IDocument, IBaseDocument } from '../models/Document';
+export type { IEnvironment } from '../models/Environment';
+export type { IExercise, ICode, IHelp } from '../models/Exercise';
+export type { IInvite } from '../models/Invite';
+export type { ILesson } from '../models/Lesson';
+export type { INotebook, IBaseNotebook } from '../models/Notebook';
+export type { ISchool } from '../models/School';
+export type { ITeam } from '../models/Team';
+export type { TeamMember } from '../models/TeamMember';
+export type { IUserOnboarding, IClient, IOnboardingPosition, IOnboardingTours, ITour, ITourStatus, } from '../models/UserOnboarding';
+export type { IUserSettings } from '../models/UserSettings';
+export type { IDataset } from '../models/Dataset';
+export type { IUsage } from '../models/Usage';
+export type { IItem } from '../models/Item';
+export type { IItemType } from '../models/ItemType';
+export type { Member } from '../models/Member';
+export type { Profile } from '../models/Profile';
+export type { SpaceMember } from '../models/SpaceMember';
+export type { IContactEvent } from '../models/ContactEvent';
+export type { IContactIAMProvider } from '../models/ContactIAMProvider';
+export type { IStudentItem } from '../models/StudentItem';
+export type { Instructor } from '../models/Instructor';
+export type { IStudent } from '../models/Student';
+export type { IDean } from '../models/Dean';
+export type { IUserEvent } from '../models/UserEvent';
+export type { IIAMProviderLinked } from '../models/IAMProviderLinked';
+export type { IContent } from '../models/Content';
+export type { AuthResult, TokenValidationResult, AuthOptions, TokenStorage, } from './auth/types';
+export type { IRuntimeOptions, IMultiServiceManager, IRemoteServicesManager, IEnvironmentsManager, IRemoteRuntimesManager, } from '../stateful/runtimes/apis';
+export type { IDatalayerCoreConfig, IRuntimesConfiguration, } from '../config/Configuration';
+export type { IIAMProviderName } from '../models/IAMProvidersSpecs';
+export type { NavigationLinkProps } from '../navigation/components';
 export { ItemTypes } from './constants';
 export type { ItemType } from './constants';
 export * from './auth';
@@ -79,6 +148,16 @@ export interface DatalayerClient {
     calculateMaxRuntimeMinutes(availableCredits: number, burningRate: number): number;
     calculateCreditsRequired(minutes: number, burningRate: number): number;
     checkIAMHealth(): Promise<HealthCheck>;
+    createSecret(data: CreateSecretRequest): Promise<SecretDTO>;
+    listSecrets(): Promise<SecretDTO[]>;
+    getSecret(secretId: string): Promise<SecretDTO>;
+    updateSecret(secretId: string, updates: UpdateSecretRequest): Promise<SecretDTO>;
+    deleteSecret(secretId: string): Promise<void>;
+    createDatasource(data: CreateDatasourceRequest): Promise<DatasourceDTO>;
+    listDatasources(): Promise<DatasourceDTO[]>;
+    getDatasource(datasourceId: string): Promise<DatasourceDTO>;
+    updateDatasource(datasourceId: string, updates: UpdateDatasourceRequest): Promise<DatasourceDTO>;
+    deleteDatasource(datasourceId: string): Promise<void>;
     listEnvironments(): Promise<EnvironmentDTO[]>;
     ensureRuntime(environmentName?: string, creditsLimit?: number, waitForReady?: boolean, maxWaitTime?: number, reuseExisting?: boolean, snapshotId?: string): Promise<RuntimeDTO>;
     createRuntime(environmentName: string, type: 'notebook' | 'terminal' | 'job', givenName: string, minutesLimit: number, fromSnapshotId?: string): Promise<RuntimeDTO>;

package/lib/client/index.js

@@ -75,7 +75,11 @@ export { LexicalDTO } from '../models/LexicalDTO';
 export { CreditsDTO as Credits } from '../models/CreditsDTO';
 export { ItemDTO as Item } from '../models/ItemDTO';
 export { HealthCheck } from '../models/HealthCheck';
-// Export constants
+export { SecretDTO as Secret } from './../models/Secret';
+export { DatasourceDTO as Datasource } from './../models/Datasource';
+// Export auth types
+export { AuthenticationManager } from './auth/AuthenticationManager';
+// Constants
 export { ItemTypes } from './constants';
 // Export authentication module
 export * from './auth';

package/lib/client/mixins/IAMMixin.d.ts

@@ -2,6 +2,10 @@ import type { Constructor } from '../utils/mixins';
 import { UserDTO } from '../../models/UserDTO';
 import { CreditsDTO } from '../../models/CreditsDTO';
 import { HealthCheck } from '../../models/HealthCheck';
+import { SecretDTO } from '../../models/Secret';
+import type { CreateSecretRequest, UpdateSecretRequest } from '../../models/Secret';
+import { DatasourceDTO } from '../../models/Datasource';
+import type { CreateDatasourceRequest, UpdateDatasourceRequest } from '../../models/Datasource';
 /** IAM mixin providing authentication and user management. */
 export declare function IAMMixin<TBase extends Constructor>(Base: TBase): {
     new (...args: any[]): {
@@ -50,5 +54,63 @@ export declare function IAMMixin<TBase extends Constructor>(Base: TBase): {
          * @returns Health check model instance
          */
         checkIAMHealth(): Promise<HealthCheck>;
+        /**
+         * Create a new secret.
+         * @param data - Secret configuration
+         * @returns Created secret instance
+         */
+        createSecret(data: CreateSecretRequest): Promise<SecretDTO>;
+        /**
+         * List all secrets.
+         * @returns Array of secret instances
+         */
+        listSecrets(): Promise<SecretDTO[]>;
+        /**
+         * Get a specific secret by ID.
+         * @param secretId - Secret unique identifier
+         * @returns Secret instance
+         */
+        getSecret(secretId: string): Promise<SecretDTO>;
+        /**
+         * Update a secret.
+         * @param secretId - Secret unique identifier
+         * @param updates - Fields to update
+         * @returns Updated secret instance
+         */
+        updateSecret(secretId: string, updates: UpdateSecretRequest): Promise<SecretDTO>;
+        /**
+         * Delete a secret.
+         * @param secretId - Secret unique identifier
+         */
+        deleteSecret(secretId: string): Promise<void>;
+        /**
+         * Create a new datasource.
+         * @param data - Datasource configuration
+         * @returns Created datasource instance
+         */
+        createDatasource(data: CreateDatasourceRequest): Promise<DatasourceDTO>;
+        /**
+         * List all datasources.
+         * @returns Array of datasource instances
+         */
+        listDatasources(): Promise<DatasourceDTO[]>;
+        /**
+         * Get a specific datasource by ID.
+         * @param datasourceId - Datasource unique identifier
+         * @returns Datasource instance
+         */
+        getDatasource(datasourceId: string): Promise<DatasourceDTO>;
+        /**
+         * Update a datasource.
+         * @param datasourceId - Datasource unique identifier
+         * @param updates - Fields to update
+         * @returns Updated datasource instance
+         */
+        updateDatasource(datasourceId: string, updates: UpdateDatasourceRequest): Promise<DatasourceDTO>;
+        /**
+         * Delete a datasource.
+         * @param datasourceId - Datasource unique identifier
+         */
+        deleteDatasource(datasourceId: string): Promise<void>;
     };
 } & TBase;

package/lib/client/mixins/IAMMixin.js

@@ -9,9 +9,13 @@
 import * as authentication from '../../api/iam/authentication';
 import * as profile from '../../api/iam/profile';
 import * as usage from '../../api/iam/usage';
+import * as secrets from '../../api/iam/secrets';
+import * as datasources from '../../api/iam/datasources';
 import { UserDTO } from '../../models/UserDTO';
 import { CreditsDTO } from '../../models/CreditsDTO';
 import { HealthCheck } from '../../models/HealthCheck';
+import { SecretDTO } from '../../models/Secret';
+import { DatasourceDTO } from '../../models/Datasource';
 /** IAM mixin providing authentication and user management. */
 export function IAMMixin(Base) {
     return class extends Base {
@@ -177,5 +181,117 @@ export function IAMMixin(Base) {
                 }, this);
             }
         }
+        // ========================================================================
+        // Secrets Management
+        // ========================================================================
+        /**
+         * Create a new secret.
+         * @param data - Secret configuration
+         * @returns Created secret instance
+         */
+        async createSecret(data) {
+            const token = this.getToken();
+            const iamRunUrl = this.getIamRunUrl();
+            const response = await secrets.createSecret(token, data, iamRunUrl);
+            return new SecretDTO(response.secret, this);
+        }
+        /**
+         * List all secrets.
+         * @returns Array of secret instances
+         */
+        async listSecrets() {
+            const token = this.getToken();
+            const iamRunUrl = this.getIamRunUrl();
+            const response = await secrets.listSecrets(token, iamRunUrl);
+            return response.secrets.map(s => new SecretDTO(s, this));
+        }
+        /**
+         * Get a specific secret by ID.
+         * @param secretId - Secret unique identifier
+         * @returns Secret instance
+         */
+        async getSecret(secretId) {
+            const token = this.getToken();
+            const iamRunUrl = this.getIamRunUrl();
+            const response = await secrets.getSecret(token, secretId, iamRunUrl);
+            return new SecretDTO(response.secret, this);
+        }
+        /**
+         * Update a secret.
+         * @param secretId - Secret unique identifier
+         * @param updates - Fields to update
+         * @returns Updated secret instance
+         */
+        async updateSecret(secretId, updates) {
+            const token = this.getToken();
+            const iamRunUrl = this.getIamRunUrl();
+            const response = await secrets.updateSecret(token, secretId, updates, iamRunUrl);
+            return new SecretDTO(response.secret, this);
+        }
+        /**
+         * Delete a secret.
+         * @param secretId - Secret unique identifier
+         */
+        async deleteSecret(secretId) {
+            const token = this.getToken();
+            const iamRunUrl = this.getIamRunUrl();
+            await secrets.deleteSecret(token, secretId, iamRunUrl);
+        }
+        // ========================================================================
+        // Datasources Management
+        // ========================================================================
+        /**
+         * Create a new datasource.
+         * @param data - Datasource configuration
+         * @returns Created datasource instance
+         */
+        async createDatasource(data) {
+            const token = this.getToken();
+            const iamRunUrl = this.getIamRunUrl();
+            const response = await datasources.createDatasource(token, data, iamRunUrl);
+            return new DatasourceDTO(response.datasource, this);
+        }
+        /**
+         * List all datasources.
+         * @returns Array of datasource instances
+         */
+        async listDatasources() {
+            const token = this.getToken();
+            const iamRunUrl = this.getIamRunUrl();
+            const response = await datasources.listDatasources(token, iamRunUrl);
+            return response.datasources.map(d => new DatasourceDTO(d, this));
+        }
+        /**
+         * Get a specific datasource by ID.
+         * @param datasourceId - Datasource unique identifier
+         * @returns Datasource instance
+         */
+        async getDatasource(datasourceId) {
+            const token = this.getToken();
+            const iamRunUrl = this.getIamRunUrl();
+            const response = await datasources.getDatasource(token, datasourceId, iamRunUrl);
+            return new DatasourceDTO(response.datasource, this);
+        }
+        /**
+         * Update a datasource.
+         * @param datasourceId - Datasource unique identifier
+         * @param updates - Fields to update
+         * @returns Updated datasource instance
+         */
+        async updateDatasource(datasourceId, updates) {
+            const token = this.getToken();
+            const iamRunUrl = this.getIamRunUrl();
+            const response = await datasources.updateDatasource(token, datasourceId, updates, iamRunUrl);
+            return new DatasourceDTO(response.datasource, this);
+        }
+        /**
+         * Delete a datasource.
+         * @param datasourceId - Datasource unique identifier
+         */
+        async deleteDatasource(datasourceId) {
+            const token = this.getToken();
+            const iamRunUrl = this.getIamRunUrl();
+            await datasources.deleteDatasource(token, datasourceId, iamRunUrl);
+        }
     };
 }

package/lib/collaboration/DatalayerCollaboration.d.ts

@@ -1,4 +1,4 @@
-type IFetchSessionId = {
+export type IFetchSessionId = {
     url: string;
     token?: string;
     /**
@@ -11,4 +11,3 @@ type IFetchSessionId = {
  * Fetch the session ID of a collaborative documents from Datalayer.
  */
 export declare function requestDatalayerCollaborationSessionId({ url, token, fetchFn, }: IFetchSessionId): Promise<string>;
-export {};

package/lib/collaboration/DatalayerCollaborationProvider.d.ts

@@ -1,7 +1,7 @@
 import { YNotebook } from '@jupyter/ydoc';
 import { WebsocketProvider } from 'y-websocket';
 import type { ICollaborationProvider, ICollaborationProviderEvents } from '@datalayer/jupyter-react';
-declare enum CollaborationStatus {
+export declare enum CollaborationStatus {
     Disconnected = "disconnected",
     Connecting = "connecting",
     Connected = "connected",

package/lib/collaboration/DatalayerCollaborationProvider.js

@@ -6,7 +6,7 @@ import { WebsocketProvider } from 'y-websocket';
 import { URLExt } from '@jupyterlab/coreutils';
 import { Signal } from '@lumino/signaling';
 // Import CollaborationStatus enum separately since it's exported
-var CollaborationStatus;
+export var CollaborationStatus;
 (function (CollaborationStatus) {
     CollaborationStatus["Disconnected"] = "disconnected";
     CollaborationStatus["Connecting"] = "connecting";