@datalayer/core 0.0.10 → 0.0.12

package/lib/sdk/client/models/__tests__/Snapshot.test.js

@@ -0,0 +1,244 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * @module sdk/client/models/__tests__/Snapshot.test
+ * @description Tests for the Snapshot domain model.
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { Snapshot } from '../Snapshot';
+import { snapshots } from '../../../../api/runtimes';
+// Mock the snapshots API
+vi.mock('../../../../api/runtimes', () => ({
+    snapshots: {
+        getSnapshot: vi.fn(),
+        deleteSnapshot: vi.fn(),
+    },
+}));
+describe('Snapshot Model', () => {
+    const mockSnapshotData = {
+        uid: 'snapshot-123',
+        name: 'Test Snapshot',
+        description: 'Test snapshot description',
+        environment: 'python-cpu',
+        metadata: {
+            version: '1.0.0',
+            language_info: {
+                name: 'python',
+                version: '3.9',
+            },
+            custom_field: 'custom_value',
+        },
+        size: 1024000,
+        format: 'tar.gz',
+        format_version: '2.0',
+        status: 'ready',
+        updated_at: '2023-01-01T12:00:00Z',
+    };
+    let mockSDK;
+    let snapshot;
+    beforeEach(() => {
+        mockSDK = {
+            getToken: vi.fn().mockReturnValue('mock-token'),
+            getRuntimesRunUrl: vi
+                .fn()
+                .mockReturnValue('https://runtimes.example.com'),
+            createRuntime: vi.fn(),
+        };
+        snapshot = new Snapshot(mockSnapshotData, mockSDK);
+        vi.clearAllMocks();
+    });
+    describe('Static Properties', () => {
+        it('should return correct uid', () => {
+            expect(snapshot.uid).toBe('snapshot-123');
+        });
+        it('should return correct name', () => {
+            expect(snapshot.name).toBe('Test Snapshot');
+        });
+        it('should return correct description', () => {
+            expect(snapshot.description).toBe('Test snapshot description');
+        });
+        it('should return correct environment', () => {
+            expect(snapshot.environment).toBe('python-cpu');
+        });
+        it('should return correct format', () => {
+            expect(snapshot.format).toBe('tar.gz');
+        });
+        it('should return correct format version', () => {
+            expect(snapshot.formatVersion).toBe('2.0');
+        });
+        it('should return correct metadata', () => {
+            expect(snapshot.metadata).toEqual({
+                version: '1.0.0',
+                language_info: {
+                    name: 'python',
+                    version: '3.9',
+                },
+                custom_field: 'custom_value',
+            });
+        });
+        it('should return correct updated date', () => {
+            expect(snapshot.updatedAt).toEqual(new Date('2023-01-01T12:00:00Z'));
+        });
+        it('should handle missing optional fields gracefully', () => {
+            const minimalData = {
+                uid: 'snapshot-456',
+                name: 'Minimal Snapshot',
+                environment: 'python-gpu',
+                updated_at: '2023-01-01T10:00:00Z',
+            };
+            const minimalSnapshot = new Snapshot(minimalData, mockSDK);
+            expect(minimalSnapshot.description).toBe('');
+            expect(minimalSnapshot.format).toBe('');
+            expect(minimalSnapshot.formatVersion).toBe('');
+            expect(minimalSnapshot.metadata).toEqual({});
+        });
+    });
+    describe('Dynamic Methods', () => {
+        beforeEach(() => {
+            snapshots.getSnapshot.mockResolvedValue({
+                snapshot: { ...mockSnapshotData, status: 'processing' },
+            });
+        });
+        it('should fetch fresh status from API and update internal data', async () => {
+            const status = await snapshot.getStatus();
+            expect(status).toBe('processing');
+            expect(snapshots.getSnapshot).toHaveBeenCalledWith('mock-token', 'snapshot-123', 'https://runtimes.example.com');
+        });
+        it('should fetch fresh size from API', async () => {
+            const updatedSize = 2048000;
+            snapshots.getSnapshot.mockResolvedValue({
+                snapshot: { ...mockSnapshotData, size: updatedSize },
+            });
+            const size = await snapshot.getSize();
+            expect(size).toBe(updatedSize);
+            expect(snapshots.getSnapshot).toHaveBeenCalledWith('mock-token', 'snapshot-123', 'https://runtimes.example.com');
+        });
+        it('should fetch fresh metadata from API', async () => {
+            const updatedMetadata = { version: '2.0.0', new_field: 'new_value' };
+            snapshots.getSnapshot.mockResolvedValue({
+                snapshot: { ...mockSnapshotData, metadata: updatedMetadata },
+            });
+            const metadata = await snapshot.getLatestMetadata();
+            expect(metadata).toEqual(updatedMetadata);
+        });
+        it('should handle missing size gracefully', async () => {
+            snapshots.getSnapshot.mockResolvedValue({
+                snapshot: { ...mockSnapshotData, size: undefined },
+            });
+            const size = await snapshot.getSize();
+            expect(size).toBe(0);
+        });
+        it('should handle missing status gracefully', async () => {
+            snapshots.getSnapshot.mockResolvedValue({
+                snapshot: { ...mockSnapshotData, status: undefined },
+            });
+            const status = await snapshot.getStatus();
+            expect(status).toBe('unknown');
+        });
+        it('should update internal data when fetching dynamic properties', async () => {
+            const updatedData = {
+                ...mockSnapshotData,
+                status: 'completed',
+                size: 3072000,
+            };
+            snapshots.getSnapshot.mockResolvedValue({
+                snapshot: updatedData,
+            });
+            await snapshot.getStatus();
+            const json = await snapshot.toJSON();
+            expect(json.status).toBe('completed');
+            expect(json.size).toBe(3072000);
+        });
+    });
+    describe('Action Methods', () => {
+        it('should delete snapshot and mark as deleted', async () => {
+            snapshots.deleteSnapshot.mockResolvedValue(undefined);
+            await snapshot.delete();
+            expect(snapshots.deleteSnapshot).toHaveBeenCalledWith('mock-token', 'snapshot-123', 'https://runtimes.example.com');
+            // After deletion, accessing properties should throw error
+            expect(() => snapshot.uid).toThrow('Snapshot snapshot-123 has been deleted and no longer exists');
+        });
+        it('should restore runtime from snapshot', async () => {
+            const mockRuntime = {
+                podName: 'runtime-from-snapshot',
+                state: 'starting',
+            };
+            mockSDK.createRuntime.mockResolvedValue(mockRuntime);
+            const runtime = await snapshot.restore({
+                credits_limit: 150,
+                custom_config: 'value',
+            });
+            expect(mockSDK.createRuntime).toHaveBeenCalledWith({
+                environment_name: 'python-cpu',
+                from_snapshot: 'snapshot-123',
+                credits_limit: 150,
+                custom_config: 'value',
+            });
+            expect(runtime).toBe(mockRuntime);
+        });
+        it('should restore runtime with minimal config', async () => {
+            const mockRuntime = { podName: 'runtime-minimal', state: 'starting' };
+            mockSDK.createRuntime.mockResolvedValue(mockRuntime);
+            const runtime = await snapshot.restore();
+            expect(mockSDK.createRuntime).toHaveBeenCalledWith({
+                environment_name: 'python-cpu',
+                from_snapshot: 'snapshot-123',
+            });
+            expect(runtime).toBe(mockRuntime);
+        });
+    });
+    describe('Utility Methods', () => {
+        it('should return JSON with fresh data', async () => {
+            const freshData = { ...mockSnapshotData, status: 'completed' };
+            snapshots.getSnapshot.mockResolvedValue({ snapshot: freshData });
+            const json = await snapshot.toJSON();
+            expect(json.status).toBe('completed');
+            expect(json.uid).toBe('snapshot-123');
+        });
+        it('should return string representation', () => {
+            expect(snapshot.toString()).toBe('Snapshot(snapshot-123, Test Snapshot)');
+        });
+    });
+    describe('Deletion State Management', () => {
+        beforeEach(async () => {
+            snapshots.deleteSnapshot.mockResolvedValue(undefined);
+            await snapshot.delete();
+        });
+        it('should throw error when accessing static properties after deletion', () => {
+            expect(() => snapshot.uid).toThrow('Snapshot snapshot-123 has been deleted and no longer exists');
+            expect(() => snapshot.name).toThrow('Snapshot snapshot-123 has been deleted and no longer exists');
+            expect(() => snapshot.description).toThrow('Snapshot snapshot-123 has been deleted and no longer exists');
+            expect(() => snapshot.environment).toThrow('Snapshot snapshot-123 has been deleted and no longer exists');
+            expect(() => snapshot.format).toThrow('Snapshot snapshot-123 has been deleted and no longer exists');
+            expect(() => snapshot.formatVersion).toThrow('Snapshot snapshot-123 has been deleted and no longer exists');
+            expect(() => snapshot.metadata).toThrow('Snapshot snapshot-123 has been deleted and no longer exists');
+            expect(() => snapshot.updatedAt).toThrow('Snapshot snapshot-123 has been deleted and no longer exists');
+        });
+        it('should throw error when calling dynamic methods after deletion', async () => {
+            await expect(snapshot.getStatus()).rejects.toThrow('Snapshot snapshot-123 has been deleted and no longer exists');
+            await expect(snapshot.getSize()).rejects.toThrow('Snapshot snapshot-123 has been deleted and no longer exists');
+            await expect(snapshot.getLatestMetadata()).rejects.toThrow('Snapshot snapshot-123 has been deleted and no longer exists');
+        });
+        it('should throw error when calling action methods after deletion', async () => {
+            await expect(snapshot.restore()).rejects.toThrow('Snapshot snapshot-123 has been deleted and no longer exists');
+        });
+        it('should throw error when calling utility methods after deletion', async () => {
+            await expect(snapshot.toJSON()).rejects.toThrow('Snapshot snapshot-123 has been deleted and no longer exists');
+            expect(() => snapshot.toString()).toThrow('Snapshot snapshot-123 has been deleted and no longer exists');
+        });
+    });
+    describe('Error Handling', () => {
+        it('should handle API errors gracefully in dynamic methods', async () => {
+            snapshots.getSnapshot.mockRejectedValue(new Error('API Error'));
+            await expect(snapshot.getStatus()).rejects.toThrow('API Error');
+        });
+        it('should handle missing snapshot in API response', async () => {
+            snapshots.getSnapshot.mockResolvedValue({ snapshot: null });
+            const status = await snapshot.getStatus();
+            // Should return the current status from internal data when API returns null
+            expect(status).toBe('ready');
+        });
+    });
+});

package/lib/sdk/client/models/__tests__/Space.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/sdk/client/models/__tests__/Space.test.js

@@ -0,0 +1,334 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * @module sdk/client/models/__tests__/Space.test
+ * @description Tests for the Space domain model.
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { Space } from '../Space';
+import { users, items } from '../../../../api/spacer';
+import { Notebook } from '../Notebook';
+import { Lexical } from '../Lexical';
+// Mock the spacer API
+vi.mock('../../../../api/spacer', () => ({
+    users: {
+        getMySpaces: vi.fn(),
+    },
+    items: {
+        getSpaceItems: vi.fn(),
+    },
+}));
+describe('Space Model', () => {
+    const mockSpaceData = {
+        uid: 'space-uid-123',
+        id: 'space-123',
+        name: 'Research Workspace',
+        name_t: 'Research Workspace',
+        handle_s: 'research-workspace',
+        variant_s: 'default',
+        description: 'Data analysis workspace',
+        description_t: 'Data analysis workspace',
+        visibility: 'private',
+        owner_id: 'user-abc',
+        organization_id: 'org-def',
+        created_at: '2023-01-01T10:00:00Z',
+        updated_at: '2023-01-02T15:30:00Z',
+        notebooks_count: 5,
+        members_count: 3,
+        tags: ['research', 'analysis'],
+        tags_ss: ['research', 'analysis'],
+    };
+    let mockSDK;
+    let space;
+    beforeEach(() => {
+        mockSDK = {
+            getToken: vi.fn().mockReturnValue('mock-token'),
+            getSpacerRunUrl: vi.fn().mockReturnValue('https://spacer.example.com'),
+            createNotebook: vi.fn(),
+            createLexical: vi.fn(),
+        };
+        space = new Space(mockSpaceData, mockSDK);
+        vi.clearAllMocks();
+    });
+    describe('Static Properties', () => {
+        it('should return correct uid', () => {
+            expect(space.uid).toBe('space-uid-123');
+        });
+        it('should return correct id', () => {
+            expect(space.id).toBe('space-123');
+        });
+        it('should return uid as id when id is not present', () => {
+            const dataWithoutId = { ...mockSpaceData, id: undefined };
+            const spaceWithoutId = new Space(dataWithoutId, mockSDK);
+            expect(spaceWithoutId.id).toBe('space-uid-123');
+        });
+        it('should return correct owner ID', () => {
+            expect(space.ownerId).toBe('user-abc');
+        });
+        it('should return correct organization ID', () => {
+            expect(space.organizationId).toBe('org-def');
+        });
+        it('should return correct created date', () => {
+            const createdAt = space.createdAt;
+            expect(createdAt).toEqual(new Date('2023-01-01T10:00:00Z'));
+        });
+        it('should return correct visibility', () => {
+            expect(space.visibility).toBe('private');
+        });
+        it('should return correct handle', () => {
+            expect(space.handle).toBe('research-workspace');
+        });
+        it('should return correct variant', () => {
+            expect(space.variant).toBe('default');
+        });
+        it('should handle missing optional fields gracefully', () => {
+            const minimalData = {
+                uid: 'space-minimal',
+                visibility: 'public',
+            };
+            const minimalSpace = new Space(minimalData, mockSDK);
+            expect(minimalSpace.ownerId).toBe('');
+            expect(minimalSpace.organizationId).toBe('');
+            expect(minimalSpace.handle).toBe('');
+            expect(minimalSpace.variant).toBe('');
+            expect(minimalSpace.createdAt).toBeNull();
+        });
+    });
+    describe('Dynamic Methods', () => {
+        beforeEach(() => {
+            users.getMySpaces.mockResolvedValue({
+                success: true,
+                spaces: [{ ...mockSpaceData, name: 'Updated Workspace Name' }],
+            });
+        });
+        it('should fetch fresh name from API and update internal data', async () => {
+            const name = await space.getName();
+            expect(name).toBe('Updated Workspace Name');
+            expect(users.getMySpaces).toHaveBeenCalledWith('mock-token', 'https://spacer.example.com');
+        });
+        it('should fetch fresh description from API', async () => {
+            const updatedDescription = 'Updated workspace description';
+            users.getMySpaces.mockResolvedValue({
+                success: true,
+                spaces: [{ ...mockSpaceData, description: updatedDescription }],
+            });
+            const description = await space.getDescription();
+            expect(description).toBe(updatedDescription);
+        });
+        it('should fetch fresh updated date from API', async () => {
+            const newUpdateTime = '2023-01-03T12:00:00Z';
+            users.getMySpaces.mockResolvedValue({
+                success: true,
+                spaces: [{ ...mockSpaceData, updated_at: newUpdateTime }],
+            });
+            const updatedAt = await space.getUpdatedAt();
+            expect(updatedAt).toEqual(new Date(newUpdateTime));
+        });
+        it('should handle missing updated_at by falling back to created_at', async () => {
+            users.getMySpaces.mockResolvedValue({
+                success: true,
+                spaces: [{ ...mockSpaceData, updated_at: undefined }],
+            });
+            const updatedAt = await space.getUpdatedAt();
+            expect(updatedAt).toEqual(new Date(mockSpaceData.created_at));
+        });
+        it('should handle space not found in refresh', async () => {
+            users.getMySpaces.mockResolvedValue({
+                success: true,
+                spaces: [], // Empty array - space not found
+            });
+            const name = await space.getName();
+            // Should return the current name from internal data when space not found
+            expect(name).toBe('Research Workspace');
+        });
+        it('should prefer name over name_t field', async () => {
+            users.getMySpaces.mockResolvedValue({
+                success: true,
+                spaces: [
+                    { ...mockSpaceData, name: 'Primary Name', name_t: 'Secondary Name' },
+                ],
+            });
+            const name = await space.getName();
+            expect(name).toBe('Primary Name');
+        });
+        it('should use name_t when name is not present', async () => {
+            users.getMySpaces.mockResolvedValue({
+                success: true,
+                spaces: [
+                    { ...mockSpaceData, name: undefined, name_t: 'Fallback Name' },
+                ],
+            });
+            const name = await space.getName();
+            expect(name).toBe('Fallback Name');
+        });
+    });
+    describe('Space-specific Methods', () => {
+        it('should get space items', async () => {
+            const mockItems = [
+                { id: 'item-1', name: 'Notebook 1', type: 'notebook' },
+                { id: 'item-2', name: 'Document 1', type: 'lexical' },
+            ];
+            items.getSpaceItems.mockResolvedValue({
+                success: true,
+                items: mockItems,
+            });
+            const spaceItems = await space.getItems();
+            expect(items.getSpaceItems).toHaveBeenCalledWith('mock-token', 'space-uid-123', 'https://spacer.example.com');
+            expect(spaceItems).toEqual(mockItems);
+        });
+        it('should create notebook in space', async () => {
+            const mockNotebook = new Notebook({
+                id: 'notebook-new',
+                uid: 'notebook-uid-new',
+                name: 'New Notebook',
+            }, mockSDK);
+            mockSDK.createNotebook.mockResolvedValue(mockNotebook);
+            const formData = new FormData();
+            formData.append('name', 'New Notebook');
+            formData.append('notebookType', 'jupyter');
+            const notebook = await space.createNotebook(formData);
+            // Should automatically set spaceId
+            expect(formData.get('spaceId')).toBe('space-uid-123');
+            expect(mockSDK.createNotebook).toHaveBeenCalledWith(formData);
+            expect(notebook).toBe(mockNotebook);
+        });
+        it('should create lexical document in space', async () => {
+            const mockLexical = new Lexical({
+                id: 'lexical-new',
+                uid: 'lexical-uid-new',
+                name: 'New Document',
+            }, mockSDK);
+            mockSDK.createLexical.mockResolvedValue(mockLexical);
+            const formData = new FormData();
+            formData.append('name', 'New Document');
+            formData.append('documentType', 'lexical');
+            const lexical = await space.createLexical(formData);
+            // Should automatically set spaceId
+            expect(formData.get('spaceId')).toBe('space-uid-123');
+            expect(mockSDK.createLexical).toHaveBeenCalledWith(formData);
+            expect(lexical).toBe(mockLexical);
+        });
+        it('should override existing spaceId in formData', async () => {
+            const mockNotebook = new Notebook({
+                id: 'notebook-new',
+                uid: 'notebook-uid-new',
+                name: 'New Notebook',
+            }, mockSDK);
+            mockSDK.createNotebook.mockResolvedValue(mockNotebook);
+            const formData = new FormData();
+            formData.append('spaceId', 'wrong-space-id'); // Wrong space ID
+            formData.append('name', 'New Notebook');
+            await space.createNotebook(formData);
+            // Should override with correct spaceId
+            expect(formData.get('spaceId')).toBe('space-uid-123');
+        });
+    });
+    describe('Utility Methods', () => {
+        it('should return JSON with fresh data', async () => {
+            const freshData = { ...mockSpaceData, name: 'Fresh Workspace Name' };
+            users.getMySpaces.mockResolvedValue({
+                success: true,
+                spaces: [freshData],
+            });
+            const json = await space.toJSON();
+            expect(json.name).toBe('Fresh Workspace Name');
+            expect(json.uid).toBe('space-uid-123');
+        });
+        it('should return string representation with name', () => {
+            expect(space.toString()).toBe('Space(space-uid-123, Research Workspace)');
+        });
+        it('should use name_t in toString when name is not present', () => {
+            const dataWithoutName = { ...mockSpaceData, name: undefined };
+            const spaceWithoutName = new Space(dataWithoutName, mockSDK);
+            expect(spaceWithoutName.toString()).toBe('Space(space-uid-123, Research Workspace)');
+        });
+        it('should use "Unnamed" in toString when no name fields present', () => {
+            const dataWithoutNames = {
+                ...mockSpaceData,
+                name: undefined,
+                name_t: undefined,
+            };
+            const spaceWithoutNames = new Space(dataWithoutNames, mockSDK);
+            expect(spaceWithoutNames.toString()).toBe('Space(space-uid-123, Unnamed)');
+        });
+    });
+    describe('Deletion State Management', () => {
+        beforeEach(() => {
+            // Mark space as deleted by setting the private flag
+            space._deleted = true;
+        });
+        it('should throw error when accessing static properties after deletion', () => {
+            expect(() => space.uid).toThrow('Space space-uid-123 has been deleted and no longer exists');
+            expect(() => space.id).toThrow('Space space-uid-123 has been deleted and no longer exists');
+            expect(() => space.ownerId).toThrow('Space space-uid-123 has been deleted and no longer exists');
+            expect(() => space.organizationId).toThrow('Space space-uid-123 has been deleted and no longer exists');
+            expect(() => space.createdAt).toThrow('Space space-uid-123 has been deleted and no longer exists');
+            expect(() => space.visibility).toThrow('Space space-uid-123 has been deleted and no longer exists');
+            expect(() => space.handle).toThrow('Space space-uid-123 has been deleted and no longer exists');
+            expect(() => space.variant).toThrow('Space space-uid-123 has been deleted and no longer exists');
+        });
+        it('should throw error when calling dynamic methods after deletion', async () => {
+            await expect(space.getName()).rejects.toThrow('Space space-uid-123 has been deleted and no longer exists');
+            await expect(space.getDescription()).rejects.toThrow('Space space-uid-123 has been deleted and no longer exists');
+            await expect(space.getUpdatedAt()).rejects.toThrow('Space space-uid-123 has been deleted and no longer exists');
+        });
+        it('should throw error when calling space-specific methods after deletion', async () => {
+            await expect(space.getItems()).rejects.toThrow('Space space-uid-123 has been deleted and no longer exists');
+            await expect(space.createNotebook(new FormData())).rejects.toThrow('Space space-uid-123 has been deleted and no longer exists');
+            await expect(space.createLexical(new FormData())).rejects.toThrow('Space space-uid-123 has been deleted and no longer exists');
+        });
+        it('should throw error when calling utility methods after deletion', async () => {
+            await expect(space.toJSON()).rejects.toThrow('Space space-uid-123 has been deleted and no longer exists');
+            expect(() => space.toString()).toThrow('Space space-uid-123 has been deleted and no longer exists');
+        });
+    });
+    describe('Error Handling', () => {
+        it('should handle API errors gracefully in dynamic methods', async () => {
+            users.getMySpaces.mockRejectedValue(new Error('API Error'));
+            await expect(space.getName()).rejects.toThrow('API Error');
+        });
+        it('should handle API errors in getItems method', async () => {
+            items.getSpaceItems.mockRejectedValue(new Error('Items fetch failed'));
+            await expect(space.getItems()).rejects.toThrow('Items fetch failed');
+        });
+        it('should handle errors in createNotebook', async () => {
+            mockSDK.createNotebook.mockRejectedValue(new Error('Creation failed'));
+            await expect(space.createNotebook(new FormData())).rejects.toThrow('Creation failed');
+        });
+        it('should handle errors in createLexical', async () => {
+            mockSDK.createLexical.mockRejectedValue(new Error('Creation failed'));
+            await expect(space.createLexical(new FormData())).rejects.toThrow('Creation failed');
+        });
+    });
+    describe('Edge Cases', () => {
+        it('should handle empty description gracefully', async () => {
+            users.getMySpaces.mockResolvedValue({
+                success: true,
+                spaces: [{ ...mockSpaceData, description: '', description_t: '' }],
+            });
+            const description = await space.getDescription();
+            expect(description).toBe('');
+        });
+        it('should handle missing timestamps gracefully', async () => {
+            users.getMySpaces.mockResolvedValue({
+                success: true,
+                spaces: [
+                    { ...mockSpaceData, updated_at: undefined, created_at: undefined },
+                ],
+            });
+            // Should return null when no timestamps are available
+            const updatedAt = await space.getUpdatedAt();
+            expect(updatedAt).toBeNull();
+        });
+        it('should handle empty items response', async () => {
+            items.getSpaceItems.mockResolvedValue({
+                success: true,
+                items: [],
+            });
+            const spaceItems = await space.getItems();
+            expect(spaceItems).toEqual([]);
+        });
+    });
+});

package/lib/sdk/client/models/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @module sdk/client/models
+ * @description Domain model classes for the Datalayer SDK.
+ *
+ * These models provide rich, object-oriented interfaces for working with
+ * Datalayer platform resources, wrapping API responses with convenient
+ * methods and automatic state management.
+ *
+ * @example
+ * ```typescript
+ * import { Runtime, Snapshot, Notebook, Lexical, Space } from '@datalayer/core/sdk/client/models';
+ *
+ * // Models are typically created by SDK methods
+ * const runtime = await sdk.createRuntime(config);
+ * const snapshot = await runtime.createSnapshot('checkpoint');
+ * const notebook = await sdk.createNotebook(formData);
+ * const lexical = await sdk.createLexical(formData);
+ * const space = await sdk.createSpace(config);
+ * ```
+ */
+export { Runtime } from './Runtime';
+export { Snapshot } from './Snapshot';
+export { Notebook } from './Notebook';
+export { Lexical } from './Lexical';
+export { Space } from './Space';
+export type { RuntimeData } from './Runtime';
+export type { RuntimeSnapshot } from './Snapshot';
+export type { NotebookData } from './Notebook';
+export type { LexicalData } from './Lexical';
+export type { SpaceData } from './Space';

package/lib/sdk/client/models/index.js

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * @module sdk/client/models
+ * @description Domain model classes for the Datalayer SDK.
+ *
+ * These models provide rich, object-oriented interfaces for working with
+ * Datalayer platform resources, wrapping API responses with convenient
+ * methods and automatic state management.
+ *
+ * @example
+ * ```typescript
+ * import { Runtime, Snapshot, Notebook, Lexical, Space } from '@datalayer/core/sdk/client/models';
+ *
+ * // Models are typically created by SDK methods
+ * const runtime = await sdk.createRuntime(config);
+ * const snapshot = await runtime.createSnapshot('checkpoint');
+ * const notebook = await sdk.createNotebook(formData);
+ * const lexical = await sdk.createLexical(formData);
+ * const space = await sdk.createSpace(config);
+ * ```
+ */
+// Export domain model classes
+export { Runtime } from './Runtime';
+export { Snapshot } from './Snapshot';
+export { Notebook } from './Notebook';
+export { Lexical } from './Lexical';
+export { Space } from './Space';