@semiont/api-client 0.1.0-build.6

package/README.md

@@ -0,0 +1,85 @@
+# @semiont/api-client
+
+TypeScript SDK for [Semiont](https://github.com/The-AI-Alliance/semiont) - a knowledge management system for semantic annotations, AI-powered entity detection, and collaborative document analysis.
+
+## What is Semiont?
+
+Semiont lets you:
+
+- **Store and manage documents** (text, markdown, code)
+- **Create semantic annotations** using W3C Web Annotation standard
+- **Link and reference** between documents
+- **Track provenance** with event sourcing
+- **Collaborate in real-time** via SSE streams
+- **Detect entities** using AI (people, organizations, concepts)
+- **Retrieve context** for LLMs via graph traversal
+- **Generate new documents** from annotations with AI
+
+## Installation
+
+```bash
+npm install @semiont/api-client
+```
+
+**Prerequisites**: Semiont backend running. See [Running the Backend](../../apps/backend/README.md#quick-start) for setup.
+
+## Quick Start
+
+```typescript
+import { SemiontApiClient, baseUrl, email, resourceUri } from '@semiont/api-client';
+
+const client = new SemiontApiClient({
+  baseUrl: baseUrl('http://localhost:4000'),
+});
+
+// Authenticate (local development mode)
+await client.authenticateLocal(email('user@example.com'));
+
+// Create a text document
+const { resource } = await client.createResource({
+  name: 'My Document',
+  file: Buffer.from('The quick brown fox jumps over the lazy dog.'),
+  format: 'text/plain',
+  entityTypes: ['example']
+});
+
+console.log('Created resource:', resource['@id']);
+
+// Detect entities with AI
+const stream = client.sse.detectAnnotations(resourceUri(resource['@id']), {
+  entityTypes: ['Animal', 'Color']
+});
+
+stream.onProgress((p) => console.log(`Scanning: ${p.currentEntityType}`));
+stream.onComplete((result) => console.log(`Found ${result.foundCount} entities`));
+
+// Get annotations
+const annotations = await client.getResourceAnnotations(resourceUri(resource['@id']));
+console.log('Annotations:', annotations.annotations.length);
+```
+
+## Documentation
+
+📚 **[Usage Guide](./docs/Usage.md)** - Authentication, resources, annotations, SSE streaming
+
+📖 **[API Reference](./docs/API-Reference.md)** - Complete method documentation
+
+## Key Features
+
+- **Type-safe** - Generated from OpenAPI spec with branded types
+- **W3C compliant** - Web Annotation standard
+- **Real-time** - SSE streaming for long operations
+- **Framework-agnostic** - Works everywhere JavaScript runs
+
+## Use Cases
+
+- ✅ MCP servers and AI integrations
+- ✅ Frontend applications (wrap with React hooks)
+- ✅ CLI tools and automation scripts
+- ✅ Third-party integrations
+
+❌ **Not for backend internal code** - Use [`@semiont/core`](../core/) instead
+
+## License
+
+Apache-2.0

package/dist/__tests__/client.test.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Unit tests for SemiontApiClient with mocked HTTP
+ */
+export {};
+/**
+ * Example usage documentation
+ *
+ * Archive a resource:
+ * ```typescript
+ * await client.updateResource(resourceUri, { archived: true });
+ * ```
+ *
+ * Unarchive a resource:
+ * ```typescript
+ * await client.updateResource(resourceUri, { archived: false });
+ * ```
+ *
+ * List active resources only:
+ * ```typescript
+ * const active = await client.listResources(20, false);
+ * ```
+ *
+ * List archived resources only:
+ * ```typescript
+ * const archived = await client.listResources(20, true);
+ * ```
+ */
+//# sourceMappingURL=client.test.d.ts.map

package/dist/__tests__/client.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/client.test.ts"],"names":[],"mappings":"AAAA;;GAEG;;AA+pBH;;;;;;;;;;;;;;;;;;;;;;GAsBG"}

package/dist/__tests__/client.test.js

@@ -0,0 +1,567 @@
+"use strict";
+/**
+ * Unit tests for SemiontApiClient with mocked HTTP
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+// Mock ky module
+vitest_1.vi.mock('ky', () => ({
+    default: {
+        create: vitest_1.vi.fn(),
+    },
+}));
+const ky_1 = __importDefault(require("ky"));
+const client_1 = require("../client");
+const branded_types_1 = require("../branded-types");
+(0, vitest_1.describe)('SemiontApiClient - Archive Operations', () => {
+    let client;
+    let mockKy;
+    const testBaseUrl = (0, branded_types_1.baseUrl)('http://localhost:4000');
+    const testResourceUri = `${testBaseUrl}/resources/test-resource-id`;
+    (0, vitest_1.beforeEach)(() => {
+        // Create mock ky instance with chainable methods
+        mockKy = {
+            get: vitest_1.vi.fn(),
+            post: vitest_1.vi.fn(),
+            patch: vitest_1.vi.fn(),
+            put: vitest_1.vi.fn(),
+            delete: vitest_1.vi.fn(),
+        };
+        // Mock ky.create to return our mock instance
+        vitest_1.vi.mocked(ky_1.default.create).mockReturnValue(mockKy);
+        client = new client_1.SemiontApiClient({
+            baseUrl: testBaseUrl,
+            timeout: 10000,
+        });
+    });
+    (0, vitest_1.describe)('updateResource - archive operations', () => {
+        (0, vitest_1.test)('should archive a resource', async () => {
+            const mockResponse = {
+                resource: {
+                    id: 'test-resource-id',
+                    name: 'Test Resource',
+                    archived: true,
+                    entityTypes: [],
+                },
+                annotations: [],
+                entityReferences: [],
+            };
+            vitest_1.vi.mocked(mockKy.patch).mockReturnValue({
+                json: vitest_1.vi.fn().mockResolvedValue(mockResponse),
+            });
+            const result = await client.updateResource(testResourceUri, {
+                archived: true,
+            });
+            (0, vitest_1.expect)(result.resource.archived).toBe(true);
+            (0, vitest_1.expect)(mockKy.patch).toHaveBeenCalledWith(testResourceUri, vitest_1.expect.objectContaining({
+                json: { archived: true },
+            }));
+        });
+        (0, vitest_1.test)('should unarchive a resource', async () => {
+            const mockResponse = {
+                resource: {
+                    id: 'test-resource-id',
+                    name: 'Test Resource',
+                    archived: false,
+                    entityTypes: [],
+                },
+                annotations: [],
+                entityReferences: [],
+            };
+            vitest_1.vi.mocked(mockKy.patch).mockReturnValue({
+                json: vitest_1.vi.fn().mockResolvedValue(mockResponse),
+            });
+            const result = await client.updateResource(testResourceUri, {
+                archived: false,
+            });
+            (0, vitest_1.expect)(result.resource.archived).toBe(false);
+            (0, vitest_1.expect)(mockKy.patch).toHaveBeenCalledWith(testResourceUri, vitest_1.expect.objectContaining({
+                json: { archived: false },
+            }));
+        });
+        (0, vitest_1.test)('should update entity types and archive in single operation', async () => {
+            const mockResponse = {
+                resource: {
+                    id: 'test-resource-id',
+                    name: 'Test Resource',
+                    archived: true,
+                    entityTypes: ['article', 'draft'],
+                },
+                annotations: [],
+                entityReferences: [],
+            };
+            vitest_1.vi.mocked(mockKy.patch).mockReturnValue({
+                json: vitest_1.vi.fn().mockResolvedValue(mockResponse),
+            });
+            const result = await client.updateResource(testResourceUri, {
+                archived: true,
+                entityTypes: ['article', 'draft'],
+            });
+            (0, vitest_1.expect)(result.resource.archived).toBe(true);
+            (0, vitest_1.expect)(result.resource.entityTypes).toEqual(['article', 'draft']);
+            (0, vitest_1.expect)(mockKy.patch).toHaveBeenCalledWith(testResourceUri, vitest_1.expect.objectContaining({
+                json: {
+                    archived: true,
+                    entityTypes: ['article', 'draft'],
+                },
+            }));
+        });
+    });
+    (0, vitest_1.describe)('listResources - filter by archived', () => {
+        (0, vitest_1.test)('should list only active resources', async () => {
+            const mockResponse = {
+                resources: [
+                    { id: 'res1', name: 'Active 1', archived: false },
+                    { id: 'res2', name: 'Active 2', archived: false },
+                ],
+                total: 2,
+            };
+            vitest_1.vi.mocked(mockKy.get).mockReturnValue({
+                json: vitest_1.vi.fn().mockResolvedValue(mockResponse),
+            });
+            const result = await client.listResources(10, false);
+            (0, vitest_1.expect)(result.resources).toHaveLength(2);
+            (0, vitest_1.expect)(result.resources.every(r => !r.archived)).toBe(true);
+            (0, vitest_1.expect)(mockKy.get).toHaveBeenCalledWith(`${testBaseUrl}/resources`, vitest_1.expect.objectContaining({
+                searchParams: vitest_1.expect.any(URLSearchParams),
+            }));
+        });
+        (0, vitest_1.test)('should list only archived resources', async () => {
+            const mockResponse = {
+                resources: [
+                    { id: 'res3', name: 'Archived 1', archived: true },
+                ],
+                total: 1,
+            };
+            vitest_1.vi.mocked(mockKy.get).mockReturnValue({
+                json: vitest_1.vi.fn().mockResolvedValue(mockResponse),
+            });
+            const result = await client.listResources(10, true);
+            (0, vitest_1.expect)(result.resources).toHaveLength(1);
+            (0, vitest_1.expect)(result.resources.every(r => r.archived)).toBe(true);
+            (0, vitest_1.expect)(mockKy.get).toHaveBeenCalledWith(`${testBaseUrl}/resources`, vitest_1.expect.objectContaining({
+                searchParams: vitest_1.expect.any(URLSearchParams),
+            }));
+        });
+    });
+    (0, vitest_1.describe)('Entity Detection and Jobs', () => {
+        (0, vitest_1.test)('should get job status', async () => {
+            const mockResponse = {
+                jobId: 'job-123',
+                type: 'detection',
+                status: 'running',
+                userId: 'user-1',
+                created: '2024-01-01T00:00:00Z',
+                progress: {
+                    current: 50,
+                    total: 100,
+                    message: 'Processing entities...',
+                },
+            };
+            vitest_1.vi.mocked(mockKy.get).mockReturnValue({
+                json: vitest_1.vi.fn().mockResolvedValue(mockResponse),
+            });
+            const result = await client.getJobStatus((0, branded_types_1.jobId)('job-123'));
+            (0, vitest_1.expect)(result.status).toBe('running');
+            (0, vitest_1.expect)(result.jobId).toBe('job-123');
+            (0, vitest_1.expect)(mockKy.get).toHaveBeenCalledWith(`${testBaseUrl}/api/jobs/job-123`);
+        });
+        (0, vitest_1.test)('should poll job until complete', async () => {
+            const responses = [
+                { jobId: 'job-123', status: 'pending', type: 'detection', created: '2024-01-01T00:00:00Z', userId: 'user-1' },
+                { jobId: 'job-123', status: 'running', type: 'detection', created: '2024-01-01T00:00:00Z', userId: 'user-1' },
+                { jobId: 'job-123', status: 'complete', type: 'detection', created: '2024-01-01T00:00:00Z', userId: 'user-1', result: { detected: 5 } },
+            ];
+            let callCount = 0;
+            vitest_1.vi.mocked(mockKy.get).mockImplementation(() => ({
+                json: vitest_1.vi.fn().mockResolvedValue(responses[callCount++]),
+            }));
+            const progressCalls = [];
+            const result = await client.pollJobUntilComplete((0, branded_types_1.jobId)('job-123'), {
+                interval: 10, // Fast polling for tests
+                onProgress: (status) => progressCalls.push(status),
+            });
+            (0, vitest_1.expect)(result.status).toBe('complete');
+            (0, vitest_1.expect)(progressCalls).toHaveLength(3);
+            (0, vitest_1.expect)(progressCalls[0].status).toBe('pending');
+            (0, vitest_1.expect)(progressCalls[1].status).toBe('running');
+            (0, vitest_1.expect)(progressCalls[2].status).toBe('complete');
+        });
+        (0, vitest_1.test)('should timeout when polling takes too long', async () => {
+            vitest_1.vi.mocked(mockKy.get).mockReturnValue({
+                json: vitest_1.vi.fn().mockResolvedValue({
+                    jobId: 'job-123',
+                    status: 'running',
+                    type: 'detection',
+                    created: '2024-01-01T00:00:00Z',
+                    userId: 'user-1',
+                }),
+            });
+            await (0, vitest_1.expect)(client.pollJobUntilComplete((0, branded_types_1.jobId)('job-123'), {
+                interval: 10,
+                timeout: 50, // Very short timeout for testing
+            })).rejects.toThrow('Job polling timeout after 50ms');
+        });
+    });
+    (0, vitest_1.describe)('LLM Context Operations', () => {
+        (0, vitest_1.test)('should get resource LLM context with default options', async () => {
+            const mockResponse = {
+                mainResource: {
+                    '@context': 'http://www.w3.org/ns/anno.jsonld',
+                    '@id': 'test-resource-id',
+                    name: 'Test Resource',
+                    content: 'Full content here',
+                },
+                relatedResources: [],
+                annotations: [],
+                graph: { nodes: [], edges: [] },
+            };
+            vitest_1.vi.mocked(mockKy.get).mockReturnValue({
+                json: vitest_1.vi.fn().mockResolvedValue(mockResponse),
+            });
+            const result = await client.getResourceLLMContext(testResourceUri);
+            (0, vitest_1.expect)(result.mainResource.name).toBe('Test Resource');
+            (0, vitest_1.expect)(mockKy.get).toHaveBeenCalledWith(`${testResourceUri}/llm-context`, vitest_1.expect.objectContaining({
+                searchParams: vitest_1.expect.any(URLSearchParams),
+            }));
+        });
+        (0, vitest_1.test)('should get resource LLM context with custom options', async () => {
+            const mockResponse = {
+                mainResource: {
+                    '@context': 'http://www.w3.org/ns/anno.jsonld',
+                    '@id': 'test-resource-id',
+                    name: 'Test Resource',
+                },
+                relatedResources: [],
+                annotations: [],
+                graph: { nodes: [], edges: [] },
+            };
+            vitest_1.vi.mocked(mockKy.get).mockReturnValue({
+                json: vitest_1.vi.fn().mockResolvedValue(mockResponse),
+            });
+            const result = await client.getResourceLLMContext(testResourceUri, {
+                depth: 3,
+                maxResources: 15,
+                includeContent: true,
+                includeSummary: true,
+            });
+            (0, vitest_1.expect)(result.mainResource).toBeDefined();
+            const call = vitest_1.vi.mocked(mockKy.get).mock.calls[0];
+            const searchParams = call[1]?.searchParams;
+            (0, vitest_1.expect)(searchParams.get('depth')).toBe('3');
+            (0, vitest_1.expect)(searchParams.get('maxResources')).toBe('15');
+            (0, vitest_1.expect)(searchParams.get('includeContent')).toBe('true');
+            (0, vitest_1.expect)(searchParams.get('includeSummary')).toBe('true');
+        });
+        (0, vitest_1.test)('should get annotation LLM context with default options', async () => {
+            const annotationId = 'ann-123';
+            const mockResponse = {
+                annotation: {
+                    '@context': 'http://www.w3.org/ns/anno.jsonld',
+                    type: 'Annotation',
+                    id: 'ann-123',
+                    motivation: 'highlighting',
+                    target: { source: testResourceUri },
+                    body: [],
+                },
+                sourceResource: {
+                    '@context': 'http://www.w3.org/ns/anno.jsonld',
+                    '@id': 'source-id',
+                    name: 'Source Resource',
+                },
+                targetResource: null,
+                sourceContext: {
+                    before: 'Text before',
+                    selected: 'Selected text',
+                    after: 'Text after',
+                },
+            };
+            vitest_1.vi.mocked(mockKy.get).mockReturnValue({
+                json: vitest_1.vi.fn().mockResolvedValue(mockResponse),
+            });
+            const result = await client.getAnnotationLLMContext(testResourceUri, annotationId);
+            (0, vitest_1.expect)(result.annotation.id).toBe('ann-123');
+            (0, vitest_1.expect)(mockKy.get).toHaveBeenCalledWith(`${testResourceUri}/annotations/${annotationId}/llm-context`, vitest_1.expect.objectContaining({
+                searchParams: vitest_1.expect.any(URLSearchParams),
+            }));
+        });
+        (0, vitest_1.test)('should get annotation LLM context with custom options', async () => {
+            const annotationId = 'ann-123';
+            const mockResponse = {
+                annotation: {
+                    '@context': 'http://www.w3.org/ns/anno.jsonld',
+                    type: 'Annotation',
+                    id: 'ann-123',
+                    motivation: 'linking',
+                    target: { source: testResourceUri },
+                    body: [],
+                },
+                sourceResource: {
+                    '@context': 'http://www.w3.org/ns/anno.jsonld',
+                    '@id': 'source-id',
+                    name: 'Source',
+                },
+                targetResource: null,
+                sourceContext: {
+                    before: 'Limited',
+                    selected: 'text',
+                    after: 'here',
+                },
+            };
+            vitest_1.vi.mocked(mockKy.get).mockReturnValue({
+                json: vitest_1.vi.fn().mockResolvedValue(mockResponse),
+            });
+            const result = await client.getAnnotationLLMContext(testResourceUri, annotationId, {
+                contextWindow: 500,
+            });
+            (0, vitest_1.expect)(result.sourceContext).toBeDefined();
+            const call = vitest_1.vi.mocked(mockKy.get).mock.calls[0];
+            const searchParams = call[1]?.searchParams;
+            (0, vitest_1.expect)(searchParams.get('contextWindow')).toBe('500');
+        });
+    });
+    (0, vitest_1.describe)('User Operations', () => {
+        (0, vitest_1.test)('should logout user', async () => {
+            const mockResponse = {
+                message: 'Logged out successfully',
+            };
+            vitest_1.vi.mocked(mockKy.post).mockReturnValue({
+                json: vitest_1.vi.fn().mockResolvedValue(mockResponse),
+            });
+            const result = await client.logout();
+            (0, vitest_1.expect)(result.message).toBe('Logged out successfully');
+            (0, vitest_1.expect)(mockKy.post).toHaveBeenCalledWith(`${testBaseUrl}/api/users/logout`);
+        });
+    });
+    (0, vitest_1.describe)('System Status', () => {
+        (0, vitest_1.test)('should get system status', async () => {
+            const mockResponse = {
+                status: 'healthy',
+                version: '1.0.0',
+                features: {
+                    semanticContent: 'enabled',
+                    collaboration: 'enabled',
+                    rbac: 'disabled',
+                },
+            };
+            vitest_1.vi.mocked(mockKy.get).mockReturnValue({
+                json: vitest_1.vi.fn().mockResolvedValue(mockResponse),
+            });
+            const result = await client.getStatus();
+            (0, vitest_1.expect)(result.version).toBe('1.0.0');
+            (0, vitest_1.expect)(result.features.semanticContent).toBe('enabled');
+            (0, vitest_1.expect)(mockKy.get).toHaveBeenCalledWith(`${testBaseUrl}/api/status`);
+        });
+    });
+    (0, vitest_1.describe)('Entity Types Bulk Operations', () => {
+        (0, vitest_1.test)('should add multiple entity types at once', async () => {
+            const mockResponse = {
+                success: true,
+                entityTypes: ['concept', 'person', 'organization'],
+            };
+            vitest_1.vi.mocked(mockKy.post).mockReturnValue({
+                json: vitest_1.vi.fn().mockResolvedValue(mockResponse),
+            });
+            const result = await client.addEntityTypesBulk([(0, branded_types_1.entityType)('concept'), (0, branded_types_1.entityType)('person'), (0, branded_types_1.entityType)('organization')]);
+            (0, vitest_1.expect)(result.success).toBe(true);
+            (0, vitest_1.expect)(result.entityTypes).toHaveLength(3);
+            (0, vitest_1.expect)(mockKy.post).toHaveBeenCalledWith(`${testBaseUrl}/api/entity-types/bulk`, vitest_1.expect.objectContaining({
+                json: { tags: [(0, branded_types_1.entityType)('concept'), (0, branded_types_1.entityType)('person'), (0, branded_types_1.entityType)('organization')] },
+            }));
+        });
+    });
+    (0, vitest_1.describe)('Annotation History', () => {
+        (0, vitest_1.test)('should get annotation event history', async () => {
+            const annotationUri = `${testResourceUri}/annotations/ann-123`;
+            const mockResponse = {
+                events: [
+                    {
+                        id: 'evt-1',
+                        type: 'highlight.created',
+                        timestamp: '2024-01-01T00:00:00Z',
+                        userId: 'user-1',
+                        resourceId: 'test-resource-id',
+                        payload: { highlightId: 'ann-123' },
+                        metadata: {
+                            sequenceNumber: 1,
+                            prevEventHash: 'hash-0',
+                            checksum: 'checksum-1',
+                        },
+                    },
+                    {
+                        id: 'evt-2',
+                        type: 'highlight.updated',
+                        timestamp: '2024-01-01T00:01:00Z',
+                        userId: 'user-1',
+                        resourceId: 'test-resource-id',
+                        payload: { highlightId: 'ann-123' },
+                        metadata: {
+                            sequenceNumber: 2,
+                            prevEventHash: 'hash-1',
+                            checksum: 'checksum-2',
+                        },
+                    },
+                ],
+                total: 2,
+                annotationId: 'ann-123',
+                resourceId: 'test-resource-id',
+            };
+            vitest_1.vi.mocked(mockKy.get).mockReturnValue({
+                json: vitest_1.vi.fn().mockResolvedValue(mockResponse),
+            });
+            const result = await client.getAnnotationHistory(annotationUri);
+            (0, vitest_1.expect)(result.total).toBe(2);
+            (0, vitest_1.expect)(result.events).toHaveLength(2);
+            (0, vitest_1.expect)(result.annotationId).toBe('ann-123');
+            (0, vitest_1.expect)(result.events[0].metadata.sequenceNumber).toBe(1);
+            (0, vitest_1.expect)(mockKy.get).toHaveBeenCalledWith(`${annotationUri}/history`);
+        });
+    });
+    (0, vitest_1.describe)('W3C Content Negotiation', () => {
+        (0, vitest_1.test)('should get resource representation with default accept header', async () => {
+            const mockText = '# Hello World\n\nThis is markdown content.';
+            const mockBuffer = new TextEncoder().encode(mockText).buffer;
+            vitest_1.vi.mocked(mockKy.get).mockReturnValue({
+                headers: {
+                    get: vitest_1.vi.fn((header) => header === 'content-type' ? 'text/plain' : null)
+                },
+                arrayBuffer: vitest_1.vi.fn().mockResolvedValue(mockBuffer),
+            });
+            const result = await client.getResourceRepresentation(testResourceUri);
+            (0, vitest_1.expect)(result.data).toBeInstanceOf(ArrayBuffer);
+            (0, vitest_1.expect)(result.contentType).toBe('text/plain');
+            (0, vitest_1.expect)(new TextDecoder().decode(result.data)).toBe(mockText);
+            (0, vitest_1.expect)(mockKy.get).toHaveBeenCalledWith(testResourceUri, vitest_1.expect.objectContaining({
+                headers: {
+                    Accept: 'text/plain',
+                },
+            }));
+        });
+        (0, vitest_1.test)('should get resource representation with custom accept header', async () => {
+            const mockMarkdown = '# Title\n\n## Section\n\nContent here.';
+            const mockBuffer = new TextEncoder().encode(mockMarkdown).buffer;
+            vitest_1.vi.mocked(mockKy.get).mockReturnValue({
+                headers: {
+                    get: vitest_1.vi.fn((header) => header === 'content-type' ? 'text/markdown' : null)
+                },
+                arrayBuffer: vitest_1.vi.fn().mockResolvedValue(mockBuffer),
+            });
+            const result = await client.getResourceRepresentation(testResourceUri, {
+                accept: 'text/markdown',
+            });
+            (0, vitest_1.expect)(result.data).toBeInstanceOf(ArrayBuffer);
+            (0, vitest_1.expect)(result.contentType).toBe('text/markdown');
+            (0, vitest_1.expect)(new TextDecoder().decode(result.data)).toBe(mockMarkdown);
+            (0, vitest_1.expect)(mockKy.get).toHaveBeenCalledWith(testResourceUri, vitest_1.expect.objectContaining({
+                headers: {
+                    Accept: 'text/markdown',
+                },
+            }));
+        });
+        (0, vitest_1.test)('should get resource representation with text/plain', async () => {
+            const mockText = 'Hello World';
+            const mockBuffer = new TextEncoder().encode(mockText).buffer;
+            vitest_1.vi.mocked(mockKy.get).mockReturnValue({
+                headers: {
+                    get: vitest_1.vi.fn((header) => header === 'content-type' ? 'text/plain; charset=utf-8' : null)
+                },
+                arrayBuffer: vitest_1.vi.fn().mockResolvedValue(mockBuffer),
+            });
+            const result = await client.getResourceRepresentation(testResourceUri, {
+                accept: 'text/plain',
+            });
+            (0, vitest_1.expect)(result.data).toBeInstanceOf(ArrayBuffer);
+            (0, vitest_1.expect)(result.contentType).toBe('text/plain; charset=utf-8');
+            (0, vitest_1.expect)(new TextDecoder().decode(result.data)).toBe(mockText);
+            (0, vitest_1.expect)(mockKy.get).toHaveBeenCalledWith(testResourceUri, vitest_1.expect.objectContaining({
+                headers: {
+                    Accept: 'text/plain',
+                },
+            }));
+        });
+    });
+    (0, vitest_1.describe)('Streaming Content Negotiation', () => {
+        (0, vitest_1.test)('should get resource representation as stream', async () => {
+            const mockData = new Uint8Array([1, 2, 3, 4, 5]);
+            const mockStream = new ReadableStream({
+                start(controller) {
+                    controller.enqueue(mockData);
+                    controller.close();
+                }
+            });
+            vitest_1.vi.mocked(mockKy.get).mockReturnValue({
+                headers: {
+                    get: vitest_1.vi.fn((header) => header === 'content-type' ? 'video/mp4' : null)
+                },
+                body: mockStream,
+            });
+            const result = await client.getResourceRepresentationStream(testResourceUri, {
+                accept: 'video/mp4',
+            });
+            (0, vitest_1.expect)(result.stream).toBeInstanceOf(ReadableStream);
+            (0, vitest_1.expect)(result.contentType).toBe('video/mp4');
+            (0, vitest_1.expect)(mockKy.get).toHaveBeenCalledWith(testResourceUri, vitest_1.expect.objectContaining({
+                headers: {
+                    Accept: 'video/mp4',
+                },
+            }));
+            // Verify stream can be consumed
+            const reader = result.stream.getReader();
+            const { value, done } = await reader.read();
+            (0, vitest_1.expect)(done).toBe(false);
+            (0, vitest_1.expect)(value).toEqual(mockData);
+        });
+        (0, vitest_1.test)('should throw error if response body is null', async () => {
+            vitest_1.vi.mocked(mockKy.get).mockReturnValue({
+                headers: {
+                    get: vitest_1.vi.fn(() => 'text/plain')
+                },
+                body: null,
+            });
+            await (0, vitest_1.expect)(client.getResourceRepresentationStream(testResourceUri)).rejects.toThrow('Response body is null - cannot create stream');
+        });
+        (0, vitest_1.test)('should use default content type if header missing', async () => {
+            const mockStream = new ReadableStream({
+                start(controller) {
+                    controller.close();
+                }
+            });
+            vitest_1.vi.mocked(mockKy.get).mockReturnValue({
+                headers: {
+                    get: vitest_1.vi.fn(() => null)
+                },
+                body: mockStream,
+            });
+            const result = await client.getResourceRepresentationStream(testResourceUri);
+            (0, vitest_1.expect)(result.contentType).toBe('application/octet-stream');
+            (0, vitest_1.expect)(result.stream).toBeInstanceOf(ReadableStream);
+        });
+    });
+});
+/**
+ * Example usage documentation
+ *
+ * Archive a resource:
+ * ```typescript
+ * await client.updateResource(resourceUri, { archived: true });
+ * ```
+ *
+ * Unarchive a resource:
+ * ```typescript
+ * await client.updateResource(resourceUri, { archived: false });
+ * ```
+ *
+ * List active resources only:
+ * ```typescript
+ * const active = await client.listResources(20, false);
+ * ```
+ *
+ * List archived resources only:
+ * ```typescript
+ * const archived = await client.listResources(20, true);
+ * ```
+ */
+//# sourceMappingURL=client.test.js.map