@semiont/api-client 0.2.33-build.79 → 0.2.33-build.81

package/dist/{index-BUlCf43K.d.ts → index-vuErmLIm.d.ts}

@@ -1178,7 +1178,7 @@ interface paths {
             };
             requestBody?: {
                 content: {
-                    "application/json": components["schemas"]["GetEntityTypesResponse"];
+                    "application/json": components["schemas"]["DetectReferencesStreamRequest"];
                 };
             };
             responses: {
@@ -2611,7 +2611,7 @@ interface components {
             success: boolean;
             message: string;
         };
-        DetectAnnotationsStreamRequest: {
+        DetectReferencesStreamRequest: {
             /** @description Entity types to detect (e.g., 'Person', 'Organization', 'Location') */
             entityTypes: string[];
             /** @description Include anaphoric/cataphoric references (e.g., 'the CEO', 'the tech giant') in addition to direct mentions */

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { B as BaseUrl, A as AccessToken, R as ResourceUri, E as EntityType, a as AnnotationUri, c as components, b as Email, p as paths, d as RefreshToken, G as GoogleCredential, C as ContentFormat, S as SearchQuery, e as CloneToken, f as ResourceAnnotationUri, M as Motivation, U as UserDID, J as JobId } from './index-BUlCf43K.js';
-export { $ as $defs, aA as AuthCode, ai as BoundingBox, F as FragmentSelector, ax as JWTTokenSchema, Z as LOCALES, Y as LocaleInfo, aB as MCPToken, ah as Point, i as Selector, h as SvgSelector, V as TextPosition, T as TextPositionSelector, g as TextQuoteSelector, aq as ValidatedAnnotation, av as ValidationFailure, aw as ValidationResult, au as ValidationSuccess, aF as accessToken, aP as annotationUri, aD as authCode, aN as baseUrl, aI as cloneToken, al as createCircleSvg, ak as createPolygonSvg, aj as createRectangleSvg, ag as decodeRepresentation, at as decodeWithCharset, aC as email, aL as entityType, Q as extractBoundingBox, as as extractCharset, ap as extractContext, W as findTextWithContext, a2 as formatLocaleDisplay, a3 as getAllLocaleCodes, H as getAnnotationExactText, j as getBodySource, k as getBodyType, a7 as getChecksum, x as getCommentText, aa as getCreator, ab as getDerivedFrom, D as getExactText, O as getFragmentSelector, a8 as getLanguage, a1 as getLocaleEnglishName, _ as getLocaleInfo, a0 as getLocaleNativeName, af as getNodeEncoding, a6 as getPrimaryMediaType, a5 as getPrimaryRepresentation, I as getPrimarySelector, ad as getResourceEntityTypes, a4 as getResourceId, a9 as getStorageUri, N as getSvgSelector, n as getTargetSelector, m as getTargetSource, K as getTextPositionSelector, L as getTextQuoteSelector, aE as googleCredential, q as hasTargetSelector, ac as isArchived, t as isAssessment, l as isBodyResolved, u as isComment, ae as isDraft, r as isHighlight, s as isReference, z as isResolvedReference, y as isStubReference, v as isTag, az as isValidEmail, aJ as jobId, aH as mcpToken, an as normalizeCoordinates, o as operations, am as parseSvgSelector, aG as refreshToken, aQ as resourceAnnotationUri, aO as resourceUri, ao as scaleSvgToNative, aM as searchQuery, aK as userDID, ar as validateAndCorrectOffsets, ay as validateData, P as validateSvgMarkup, X as verifyPosition, w as webhooks } from './index-BUlCf43K.js';
+import { B as BaseUrl, R as ResourceUri, E as EntityType, A as AccessToken, a as AnnotationUri, c as components, b as Email, p as paths, d as RefreshToken, G as GoogleCredential, C as ContentFormat, S as SearchQuery, e as CloneToken, f as ResourceAnnotationUri, M as Motivation, U as UserDID, J as JobId } from './index-vuErmLIm.js';
+export { $ as $defs, aA as AuthCode, ai as BoundingBox, F as FragmentSelector, ax as JWTTokenSchema, Z as LOCALES, Y as LocaleInfo, aB as MCPToken, ah as Point, i as Selector, h as SvgSelector, V as TextPosition, T as TextPositionSelector, g as TextQuoteSelector, aq as ValidatedAnnotation, av as ValidationFailure, aw as ValidationResult, au as ValidationSuccess, aF as accessToken, aP as annotationUri, aD as authCode, aN as baseUrl, aI as cloneToken, al as createCircleSvg, ak as createPolygonSvg, aj as createRectangleSvg, ag as decodeRepresentation, at as decodeWithCharset, aC as email, aL as entityType, Q as extractBoundingBox, as as extractCharset, ap as extractContext, W as findTextWithContext, a2 as formatLocaleDisplay, a3 as getAllLocaleCodes, H as getAnnotationExactText, j as getBodySource, k as getBodyType, a7 as getChecksum, x as getCommentText, aa as getCreator, ab as getDerivedFrom, D as getExactText, O as getFragmentSelector, a8 as getLanguage, a1 as getLocaleEnglishName, _ as getLocaleInfo, a0 as getLocaleNativeName, af as getNodeEncoding, a6 as getPrimaryMediaType, a5 as getPrimaryRepresentation, I as getPrimarySelector, ad as getResourceEntityTypes, a4 as getResourceId, a9 as getStorageUri, N as getSvgSelector, n as getTargetSelector, m as getTargetSource, K as getTextPositionSelector, L as getTextQuoteSelector, aE as googleCredential, q as hasTargetSelector, ac as isArchived, t as isAssessment, l as isBodyResolved, u as isComment, ae as isDraft, r as isHighlight, s as isReference, z as isResolvedReference, y as isStubReference, v as isTag, az as isValidEmail, aJ as jobId, aH as mcpToken, an as normalizeCoordinates, o as operations, am as parseSvgSelector, aG as refreshToken, aQ as resourceAnnotationUri, aO as resourceUri, ao as scaleSvgToNative, aM as searchQuery, aK as userDID, ar as validateAndCorrectOffsets, ay as validateData, P as validateSvgMarkup, X as verifyPosition, w as webhooks } from './index-vuErmLIm.js';
 
 /**
  * TypeScript types for Server-Sent Events (SSE) streaming
@@ -9,13 +9,13 @@ export { $ as $defs, aA as AuthCode, ai as BoundingBox, F as FragmentSelector, a
  * type safety for client code consuming the streams.
  */
 /**
- * Progress event for entity detection stream
+ * Progress event for reference/linking detection stream
  *
  * Sent by POST /resources/:id/detect-annotations-stream
  *
  * @example
  * ```typescript
- * stream.onProgress((progress: DetectionProgress) => {
+ * stream.onProgress((progress: ReferenceDetectionProgress) => {
  *   if (progress.status === 'scanning') {
  *     console.log(`Scanning for ${progress.currentEntityType}...`);
  *     console.log(`Progress: ${progress.processedEntityTypes}/${progress.totalEntityTypes}`);
@@ -23,7 +23,7 @@ export { $ as $defs, aA as AuthCode, ai as BoundingBox, F as FragmentSelector, a
  * });
  * ```
  */
-interface DetectionProgress {
+interface ReferenceDetectionProgress {
     /** Current status of detection operation */
     status: 'started' | 'scanning' | 'complete' | 'error';
     /** Resource ID being scanned */
@@ -311,9 +311,9 @@ interface Logger {
  */
 
 /**
- * Request body for detection stream
+ * Request body for reference detection stream
  */
-interface DetectAnnotationsStreamRequest {
+interface DetectReferencesStreamRequest {
     entityTypes: EntityType[];
     includeDescriptiveReferences?: boolean;
 }
@@ -327,12 +327,17 @@ type GenerateResourceStreamRequest = components['schemas']['GenerateResourceStre
  */
 interface DetectHighlightsStreamRequest {
     instructions?: string;
+    /** Desired number of highlights per 2000 words (1-15) */
+    density?: number;
 }
 /**
  * Request body for assessment detection stream
  */
 interface DetectAssessmentsStreamRequest {
     instructions?: string;
+    tone?: 'analytical' | 'critical' | 'balanced' | 'constructive';
+    /** Desired number of assessments per 2000 words (1-10) */
+    density?: number;
 }
 /**
  * Request body for comment detection stream
@@ -340,6 +345,8 @@ interface DetectAssessmentsStreamRequest {
 interface DetectCommentsStreamRequest {
     instructions?: string;
     tone?: 'scholarly' | 'explanatory' | 'conversational' | 'technical';
+    /** Desired number of comments per 2000 words (2-12) */
+    density?: number;
 }
 /**
  * Request body for tag detection stream
@@ -353,25 +360,32 @@ interface DetectTagsStreamRequest {
  */
 interface SSEClientConfig {
     baseUrl: BaseUrl;
-    accessToken?: AccessToken;
     logger?: Logger;
 }
+/**
+ * Options for SSE requests
+ */
+interface SSERequestOptions {
+    auth?: AccessToken;
+}
 /**
  * SSE Client for real-time streaming operations
  *
  * Separate from the main HTTP client to clearly mark streaming endpoints.
  * Uses native fetch() instead of ky for SSE support.
  *
+ * This client is stateless - auth tokens are passed per-request via options.
+ *
  * @example
  * ```typescript
  * const sseClient = new SSEClient({
- *   baseUrl: 'http://localhost:4000',
- *   accessToken: 'your-token'
+ *   baseUrl: 'http://localhost:4000'
  * });
  *
- * const stream = sseClient.detectAnnotations(
+ * const stream = sseClient.detectReferences(
  *   'http://localhost:4000/resources/doc-123',
- *   { entityTypes: ['Person', 'Organization'] }
+ *   { entityTypes: ['Person', 'Organization'] },
+ *   { auth: 'your-token' }
  * );
  *
  * stream.onProgress((p) => console.log(p.message));
@@ -381,17 +395,8 @@ interface SSEClientConfig {
  */
 declare class SSEClient {
     private baseUrl;
-    private accessToken;
     private logger?;
     constructor(config: SSEClientConfig);
-    /**
-     * Set the access token for authenticated requests
-     */
-    setAccessToken(token: AccessToken): void;
-    /**
-     * Clear the access token
-     */
-    clearAccessToken(): void;
     /**
      * Get common headers for SSE requests
      */
@@ -411,13 +416,15 @@ declare class SSEClient {
      *
      * @param resourceId - Resource URI or ID
      * @param request - Detection configuration (entity types to detect)
+     * @param options - Request options (auth token)
      * @returns SSE stream controller with progress/complete/error callbacks
      *
      * @example
      * ```typescript
-     * const stream = sseClient.detectAnnotations(
+     * const stream = sseClient.detectReferences(
      *   'http://localhost:4000/resources/doc-123',
-     *   { entityTypes: ['Person', 'Organization'] }
+     *   { entityTypes: ['Person', 'Organization'] },
+     *   { auth: 'your-token' }
      * );
      *
      * stream.onProgress((progress) => {
@@ -437,7 +444,7 @@ declare class SSEClient {
      * stream.close();
      * ```
      */
-    detectAnnotations(resourceId: ResourceUri, request: DetectAnnotationsStreamRequest): SSEStream<DetectionProgress, DetectionProgress>;
+    detectReferences(resourceId: ResourceUri, request: DetectReferencesStreamRequest, options?: SSERequestOptions): SSEStream<ReferenceDetectionProgress, ReferenceDetectionProgress>;
     /**
      * Generate resource from annotation (streaming)
      *
@@ -446,6 +453,7 @@ declare class SSEClient {
      * @param resourceId - Source resource URI or ID
      * @param annotationId - Annotation URI or ID to use as generation source
      * @param request - Generation options (title, prompt, language)
+     * @param options - Request options (auth token)
      * @returns SSE stream controller with progress/complete/error callbacks
      *
      * @example
@@ -453,7 +461,8 @@ declare class SSEClient {
      * const stream = sseClient.generateResourceFromAnnotation(
      *   'http://localhost:4000/resources/doc-123',
      *   'http://localhost:4000/annotations/ann-456',
-     *   { language: 'es', title: 'Spanish Summary' }
+     *   { language: 'es', title: 'Spanish Summary' },
+     *   { auth: 'your-token' }
      * );
      *
      * stream.onProgress((progress) => {
@@ -473,7 +482,7 @@ declare class SSEClient {
      * stream.close();
      * ```
      */
-    generateResourceFromAnnotation(resourceId: ResourceUri, annotationId: AnnotationUri, request: GenerateResourceStreamRequest): SSEStream<GenerationProgress, GenerationProgress>;
+    generateResourceFromAnnotation(resourceId: ResourceUri, annotationId: AnnotationUri, request: GenerateResourceStreamRequest, options?: SSERequestOptions): SSEStream<GenerationProgress, GenerationProgress>;
     /**
      * Detect highlights in a resource (streaming)
      *
@@ -481,13 +490,15 @@ declare class SSEClient {
      *
      * @param resourceId - Resource URI or ID
      * @param request - Detection configuration (optional instructions)
+     * @param options - Request options (auth token)
      * @returns SSE stream controller with progress/complete/error callbacks
      *
      * @example
      * ```typescript
      * const stream = sseClient.detectHighlights(
      *   'http://localhost:4000/resources/doc-123',
-     *   { instructions: 'Focus on key technical points' }
+     *   { instructions: 'Focus on key technical points' },
+     *   { auth: 'your-token' }
      * );
      *
      * stream.onProgress((progress) => {
@@ -507,7 +518,7 @@ declare class SSEClient {
      * stream.close();
      * ```
      */
-    detectHighlights(resourceId: ResourceUri, request?: DetectHighlightsStreamRequest): SSEStream<HighlightDetectionProgress, HighlightDetectionProgress>;
+    detectHighlights(resourceId: ResourceUri, request?: DetectHighlightsStreamRequest, options?: SSERequestOptions): SSEStream<HighlightDetectionProgress, HighlightDetectionProgress>;
     /**
      * Detect assessments in a resource (streaming)
      *
@@ -515,13 +526,15 @@ declare class SSEClient {
      *
      * @param resourceId - Resource URI or ID
      * @param request - Detection configuration (optional instructions)
+     * @param options - Request options (auth token)
      * @returns SSE stream controller with progress/complete/error callbacks
      *
      * @example
      * ```typescript
      * const stream = sseClient.detectAssessments(
      *   'http://localhost:4000/resources/doc-123',
-     *   { instructions: 'Evaluate claims for accuracy' }
+     *   { instructions: 'Evaluate claims for accuracy' },
+     *   { auth: 'your-token' }
      * );
      *
      * stream.onProgress((progress) => {
@@ -541,7 +554,7 @@ declare class SSEClient {
      * stream.close();
      * ```
      */
-    detectAssessments(resourceId: ResourceUri, request?: DetectAssessmentsStreamRequest): SSEStream<AssessmentDetectionProgress, AssessmentDetectionProgress>;
+    detectAssessments(resourceId: ResourceUri, request?: DetectAssessmentsStreamRequest, options?: SSERequestOptions): SSEStream<AssessmentDetectionProgress, AssessmentDetectionProgress>;
     /**
      * Detect comments in a resource (streaming)
      *
@@ -551,14 +564,19 @@ declare class SSEClient {
      *
      * @param resourceId - Resource URI or ID
      * @param request - Detection configuration (optional instructions and tone)
+     * @param options - Request options (auth token)
      * @returns SSE stream controller with progress/complete/error callbacks
      *
      * @example
      * ```typescript
-     * const stream = sseClient.detectComments('http://localhost:4000/resources/doc-123', {
-     *   instructions: 'Focus on technical terminology',
-     *   tone: 'scholarly'
-     * });
+     * const stream = sseClient.detectComments(
+     *   'http://localhost:4000/resources/doc-123',
+     *   {
+     *     instructions: 'Focus on technical terminology',
+     *     tone: 'scholarly'
+     *   },
+     *   { auth: 'your-token' }
+     * );
      *
      * stream.onProgress((progress) => {
      *   console.log(`${progress.status}: ${progress.percentage}%`);
@@ -576,7 +594,7 @@ declare class SSEClient {
      * stream.close();
      * ```
      */
-    detectComments(resourceId: ResourceUri, request?: DetectCommentsStreamRequest): SSEStream<CommentDetectionProgress, CommentDetectionProgress>;
+    detectComments(resourceId: ResourceUri, request?: DetectCommentsStreamRequest, options?: SSERequestOptions): SSEStream<CommentDetectionProgress, CommentDetectionProgress>;
     /**
      * Detect tags in a resource (streaming)
      *
@@ -586,14 +604,19 @@ declare class SSEClient {
      *
      * @param resourceId - Resource URI or ID
      * @param request - Detection configuration (schema and categories to detect)
+     * @param options - Request options (auth token)
      * @returns SSE stream controller with progress/complete/error callbacks
      *
      * @example
      * ```typescript
-     * const stream = sseClient.detectTags('http://localhost:4000/resources/doc-123', {
-     *   schemaId: 'legal-irac',
-     *   categories: ['Issue', 'Rule', 'Application', 'Conclusion']
-     * });
+     * const stream = sseClient.detectTags(
+     *   'http://localhost:4000/resources/doc-123',
+     *   {
+     *     schemaId: 'legal-irac',
+     *     categories: ['Issue', 'Rule', 'Application', 'Conclusion']
+     *   },
+     *   { auth: 'your-token' }
+     * );
      *
      * stream.onProgress((progress) => {
      *   console.log(`${progress.status}: ${progress.percentage}%`);
@@ -612,7 +635,7 @@ declare class SSEClient {
      * stream.close();
      * ```
      */
-    detectTags(resourceId: ResourceUri, request: DetectTagsStreamRequest): SSEStream<TagDetectionProgress, TagDetectionProgress>;
+    detectTags(resourceId: ResourceUri, request: DetectTagsStreamRequest, options?: SSERequestOptions): SSEStream<TagDetectionProgress, TagDetectionProgress>;
     /**
      * Subscribe to resource events (long-lived stream)
      *
@@ -622,11 +645,15 @@ declare class SSEClient {
      * This stream does NOT have a complete event - it stays open until explicitly closed.
      *
      * @param resourceId - Resource URI or ID to subscribe to
+     * @param options - Request options (auth token)
      * @returns SSE stream controller with event callback
      *
      * @example
      * ```typescript
-     * const stream = sseClient.resourceEvents('http://localhost:4000/resources/doc-123');
+     * const stream = sseClient.resourceEvents(
+     *   'http://localhost:4000/resources/doc-123',
+     *   { auth: 'your-token' }
+     * );
      *
      * stream.onProgress((event) => {
      *   console.log(`Event: ${event.type}`);
@@ -643,7 +670,9 @@ declare class SSEClient {
      * stream.close();
      * ```
      */
-    resourceEvents(resourceId: ResourceUri): SSEStream<any, never>;
+    resourceEvents(resourceId: ResourceUri, options?: SSERequestOptions & {
+        onConnected?: () => void;
+    }): SSEStream<any, never>;
 }
 
 /**
@@ -689,20 +718,26 @@ declare class APIError extends Error {
 }
 interface SemiontApiClientConfig {
     baseUrl: BaseUrl;
-    accessToken?: AccessToken;
     timeout?: number;
     retry?: number;
     logger?: Logger;
 }
+/**
+ * Options for individual API requests
+ */
+interface RequestOptions {
+    /** Access token for this request */
+    auth?: AccessToken;
+}
 /**
  * Semiont API Client
  *
  * Provides type-safe methods for all Semiont backend API endpoints.
+ * This client is fully stateless - authentication must be provided per request.
  */
 declare class SemiontApiClient {
     private http;
     private baseUrl;
-    private accessToken;
     private logger?;
     /**
      * SSE streaming client for real-time operations
@@ -714,7 +749,8 @@ declare class SemiontApiClient {
      * ```typescript
      * const stream = client.sse.detectAnnotations(
      *   resourceId,
-     *   { entityTypes: ['Person', 'Organization'] }
+     *   { entityTypes: ['Person', 'Organization'] },
+     *   { auth: accessToken }
      * );
      *
      * stream.onProgress((p) => console.log(p.message));
@@ -724,21 +760,13 @@ declare class SemiontApiClient {
      */
     readonly sse: SSEClient;
     constructor(config: SemiontApiClientConfig);
-    /**
-     * Set the access token for authenticated requests
-     */
-    setAccessToken(token: AccessToken): void;
-    /**
-     * Clear the access token
-     */
-    clearAccessToken(): void;
-    authenticatePassword(email: Email, password: string): Promise<ResponseContent<paths['/api/tokens/password']['post']>>;
-    refreshToken(token: RefreshToken): Promise<ResponseContent<paths['/api/tokens/refresh']['post']>>;
-    authenticateGoogle(credential: GoogleCredential): Promise<ResponseContent<paths['/api/tokens/google']['post']>>;
-    generateMCPToken(): Promise<ResponseContent<paths['/api/tokens/mcp-generate']['post']>>;
-    getMe(): Promise<ResponseContent<paths['/api/users/me']['get']>>;
-    acceptTerms(): Promise<ResponseContent<paths['/api/users/accept-terms']['post']>>;
-    logout(): Promise<ResponseContent<paths['/api/users/logout']['post']>>;
+    authenticatePassword(email: Email, password: string, options?: RequestOptions): Promise<ResponseContent<paths['/api/tokens/password']['post']>>;
+    refreshToken(token: RefreshToken, options?: RequestOptions): Promise<ResponseContent<paths['/api/tokens/refresh']['post']>>;
+    authenticateGoogle(credential: GoogleCredential, options?: RequestOptions): Promise<ResponseContent<paths['/api/tokens/google']['post']>>;
+    generateMCPToken(options?: RequestOptions): Promise<ResponseContent<paths['/api/tokens/mcp-generate']['post']>>;
+    getMe(options?: RequestOptions): Promise<ResponseContent<paths['/api/users/me']['get']>>;
+    acceptTerms(options?: RequestOptions): Promise<ResponseContent<paths['/api/users/accept-terms']['post']>>;
+    logout(options?: RequestOptions): Promise<ResponseContent<paths['/api/users/logout']['post']>>;
     /**
      * Create a new resource with binary content support
      *
@@ -751,6 +779,7 @@ declare class SemiontApiClient {
      * @param data.creationMethod - Optional creation method
      * @param data.sourceAnnotationId - Optional source annotation ID
      * @param data.sourceResourceId - Optional source resource ID
+     * @param options - Request options including auth
      */
     createResource(data: {
         name: string;
@@ -761,32 +790,33 @@ declare class SemiontApiClient {
         creationMethod?: string;
         sourceAnnotationId?: string;
         sourceResourceId?: string;
-    }): Promise<ResponseContent<paths['/resources']['post']>>;
-    getResource(resourceUri: ResourceUri): Promise<ResponseContent<paths['/resources/{id}']['get']>>;
+    }, options?: RequestOptions): Promise<ResponseContent<paths['/resources']['post']>>;
+    getResource(resourceUri: ResourceUri, options?: RequestOptions): Promise<ResponseContent<paths['/resources/{id}']['get']>>;
     /**
      * Get resource representation using W3C content negotiation
      * Returns raw binary content (images, PDFs, text, etc.) with content type
      *
      * @param resourceUri - Full resource URI
-     * @param options - Options including Accept header for content negotiation
+     * @param options - Options including Accept header for content negotiation and auth
      * @returns Object with data (ArrayBuffer) and contentType (string)
      *
      * @example
      * ```typescript
      * // Get markdown representation
-     * const { data, contentType } = await client.getResourceRepresentation(rUri, { accept: 'text/markdown' });
+     * const { data, contentType } = await client.getResourceRepresentation(rUri, { accept: 'text/markdown', auth: token });
      * const markdown = new TextDecoder().decode(data);
      *
      * // Get image representation
-     * const { data, contentType } = await client.getResourceRepresentation(rUri, { accept: 'image/png' });
+     * const { data, contentType } = await client.getResourceRepresentation(rUri, { accept: 'image/png', auth: token });
      * const blob = new Blob([data], { type: contentType });
      *
      * // Get PDF representation
-     * const { data, contentType } = await client.getResourceRepresentation(rUri, { accept: 'application/pdf' });
+     * const { data, contentType } = await client.getResourceRepresentation(rUri, { accept: 'application/pdf', auth: token });
      * ```
      */
     getResourceRepresentation(resourceUri: ResourceUri, options?: {
         accept?: ContentFormat;
+        auth?: AccessToken;
     }): Promise<{
         data: ArrayBuffer;
         contentType: string;
@@ -800,14 +830,15 @@ declare class SemiontApiClient {
      * until the stream is fully consumed or closed.
      *
      * @param resourceUri - Full resource URI
-     * @param options - Options including Accept header for content negotiation
+     * @param options - Options including Accept header for content negotiation and auth
      * @returns Object with stream (ReadableStream) and contentType (string)
      *
      * @example
      * ```typescript
      * // Stream large file
      * const { stream, contentType } = await client.getResourceRepresentationStream(rUri, {
-     *   accept: 'video/mp4'
+     *   accept: 'video/mp4',
+     *   auth: token
      * });
      *
      * // Consume stream chunk by chunk (never loads entire file into memory)
@@ -828,44 +859,46 @@ declare class SemiontApiClient {
      */
     getResourceRepresentationStream(resourceUri: ResourceUri, options?: {
         accept?: ContentFormat;
+        auth?: AccessToken;
     }): Promise<{
         stream: ReadableStream<Uint8Array>;
         contentType: string;
     }>;
-    listResources(limit?: number, archived?: boolean, query?: SearchQuery): Promise<ResponseContent<paths['/resources']['get']>>;
-    updateResource(resourceUri: ResourceUri, data: RequestContent<paths['/resources/{id}']['patch']>): Promise<ResponseContent<paths['/resources/{id}']['patch']>>;
-    getResourceEvents(resourceUri: ResourceUri): Promise<{
+    listResources(limit?: number, archived?: boolean, query?: SearchQuery, options?: RequestOptions): Promise<ResponseContent<paths['/resources']['get']>>;
+    updateResource(resourceUri: ResourceUri, data: RequestContent<paths['/resources/{id}']['patch']>, options?: RequestOptions): Promise<ResponseContent<paths['/resources/{id}']['patch']>>;
+    getResourceEvents(resourceUri: ResourceUri, options?: RequestOptions): Promise<{
         events: any[];
     }>;
-    getResourceAnnotations(resourceUri: ResourceUri): Promise<ResponseContent<paths['/resources/{id}/annotations']['get']>>;
+    getResourceAnnotations(resourceUri: ResourceUri, options?: RequestOptions): Promise<ResponseContent<paths['/resources/{id}/annotations']['get']>>;
     getAnnotationLLMContext(resourceUri: ResourceUri, annotationId: string, options?: {
         contextWindow?: number;
+        auth?: AccessToken;
     }): Promise<ResponseContent<paths['/resources/{resourceId}/annotations/{annotationId}/llm-context']['get']>>;
-    getResourceReferencedBy(resourceUri: ResourceUri): Promise<{
+    getResourceReferencedBy(resourceUri: ResourceUri, options?: RequestOptions): Promise<{
         referencedBy: any[];
     }>;
-    generateCloneToken(resourceUri: ResourceUri): Promise<ResponseContent<paths['/resources/{id}/clone-with-token']['post']>>;
-    getResourceByToken(token: CloneToken): Promise<ResponseContent<paths['/api/resources/token/{token}']['get']>>;
-    createResourceFromToken(data: RequestContent<paths['/api/resources/create-from-token']['post']>): Promise<ResponseContent<paths['/api/resources/create-from-token']['post']>>;
-    createAnnotation(resourceUri: ResourceUri, data: RequestContent<paths['/resources/{id}/annotations']['post']>): Promise<ResponseContent<paths['/resources/{id}/annotations']['post']>>;
-    getAnnotation(annotationUri: AnnotationUri): Promise<ResponseContent<paths['/annotations/{id}']['get']>>;
-    getResourceAnnotation(annotationUri: ResourceAnnotationUri): Promise<ResponseContent<paths['/resources/{resourceId}/annotations/{annotationId}']['get']>>;
-    listAnnotations(resourceUri: ResourceUri, motivation?: Motivation): Promise<ResponseContent<paths['/resources/{id}/annotations']['get']>>;
-    deleteAnnotation(annotationUri: ResourceAnnotationUri): Promise<void>;
-    updateAnnotationBody(annotationUri: ResourceAnnotationUri, data: RequestContent<paths['/resources/{resourceId}/annotations/{annotationId}/body']['put']>): Promise<ResponseContent<paths['/resources/{resourceId}/annotations/{annotationId}/body']['put']>>;
-    getAnnotationHistory(annotationUri: ResourceAnnotationUri): Promise<ResponseContent<paths['/resources/{resourceId}/annotations/{annotationId}/history']['get']>>;
-    addEntityType(type: EntityType): Promise<ResponseContent<paths['/api/entity-types']['post']>>;
-    addEntityTypesBulk(types: EntityType[]): Promise<ResponseContent<paths['/api/entity-types/bulk']['post']>>;
-    listEntityTypes(): Promise<ResponseContent<paths['/api/entity-types']['get']>>;
-    listUsers(): Promise<ResponseContent<paths['/api/admin/users']['get']>>;
-    getUserStats(): Promise<ResponseContent<paths['/api/admin/users/stats']['get']>>;
+    generateCloneToken(resourceUri: ResourceUri, options?: RequestOptions): Promise<ResponseContent<paths['/resources/{id}/clone-with-token']['post']>>;
+    getResourceByToken(token: CloneToken, options?: RequestOptions): Promise<ResponseContent<paths['/api/resources/token/{token}']['get']>>;
+    createResourceFromToken(data: RequestContent<paths['/api/resources/create-from-token']['post']>, options?: RequestOptions): Promise<ResponseContent<paths['/api/resources/create-from-token']['post']>>;
+    createAnnotation(resourceUri: ResourceUri, data: RequestContent<paths['/resources/{id}/annotations']['post']>, options?: RequestOptions): Promise<ResponseContent<paths['/resources/{id}/annotations']['post']>>;
+    getAnnotation(annotationUri: AnnotationUri, options?: RequestOptions): Promise<ResponseContent<paths['/annotations/{id}']['get']>>;
+    getResourceAnnotation(annotationUri: ResourceAnnotationUri, options?: RequestOptions): Promise<ResponseContent<paths['/resources/{resourceId}/annotations/{annotationId}']['get']>>;
+    listAnnotations(resourceUri: ResourceUri, motivation?: Motivation, options?: RequestOptions): Promise<ResponseContent<paths['/resources/{id}/annotations']['get']>>;
+    deleteAnnotation(annotationUri: ResourceAnnotationUri, options?: RequestOptions): Promise<void>;
+    updateAnnotationBody(annotationUri: ResourceAnnotationUri, data: RequestContent<paths['/resources/{resourceId}/annotations/{annotationId}/body']['put']>, options?: RequestOptions): Promise<ResponseContent<paths['/resources/{resourceId}/annotations/{annotationId}/body']['put']>>;
+    getAnnotationHistory(annotationUri: ResourceAnnotationUri, options?: RequestOptions): Promise<ResponseContent<paths['/resources/{resourceId}/annotations/{annotationId}/history']['get']>>;
+    addEntityType(type: EntityType, options?: RequestOptions): Promise<ResponseContent<paths['/api/entity-types']['post']>>;
+    addEntityTypesBulk(types: EntityType[], options?: RequestOptions): Promise<ResponseContent<paths['/api/entity-types/bulk']['post']>>;
+    listEntityTypes(options?: RequestOptions): Promise<ResponseContent<paths['/api/entity-types']['get']>>;
+    listUsers(options?: RequestOptions): Promise<ResponseContent<paths['/api/admin/users']['get']>>;
+    getUserStats(options?: RequestOptions): Promise<ResponseContent<paths['/api/admin/users/stats']['get']>>;
     /**
      * Update a user by ID
      * Note: Users use DID identifiers (did:web:domain:users:id), not HTTP URIs.
      */
-    updateUser(id: UserDID, data: RequestContent<paths['/api/admin/users/{id}']['patch']>): Promise<ResponseContent<paths['/api/admin/users/{id}']['patch']>>;
-    getOAuthConfig(): Promise<ResponseContent<paths['/api/admin/oauth/config']['get']>>;
-    getJobStatus(id: JobId): Promise<ResponseContent<paths['/api/jobs/{id}']['get']>>;
+    updateUser(id: UserDID, data: RequestContent<paths['/api/admin/users/{id}']['patch']>, options?: RequestOptions): Promise<ResponseContent<paths['/api/admin/users/{id}']['patch']>>;
+    getOAuthConfig(options?: RequestOptions): Promise<ResponseContent<paths['/api/admin/oauth/config']['get']>>;
+    getJobStatus(id: JobId, options?: RequestOptions): Promise<ResponseContent<paths['/api/jobs/{id}']['get']>>;
     /**
      * Poll a job until it completes or fails
      * @param id - The job ID to poll
@@ -876,15 +909,17 @@ declare class SemiontApiClient {
         interval?: number;
         timeout?: number;
         onProgress?: (status: ResponseContent<paths['/api/jobs/{id}']['get']>) => void;
+        auth?: AccessToken;
     }): Promise<ResponseContent<paths['/api/jobs/{id}']['get']>>;
     getResourceLLMContext(resourceUri: ResourceUri, options?: {
         depth?: number;
         maxResources?: number;
         includeContent?: boolean;
         includeSummary?: boolean;
+        auth?: AccessToken;
     }): Promise<ResponseContent<paths['/resources/{id}/llm-context']['get']>>;
-    healthCheck(): Promise<ResponseContent<paths['/api/health']['get']>>;
-    getStatus(): Promise<ResponseContent<paths['/api/status']['get']>>;
+    healthCheck(options?: RequestOptions): Promise<ResponseContent<paths['/api/health']['get']>>;
+    getStatus(options?: RequestOptions): Promise<ResponseContent<paths['/api/status']['get']>>;
 }
 
 /**
@@ -959,4 +994,4 @@ declare function getMimeCategory(mimeType: string): MimeCategory;
 type GenerationContext = components['schemas']['GenerationContext'];
 type AnnotationLLMContextResponse = components['schemas']['AnnotationLLMContextResponse'];
 
-export { APIError, AccessToken, type AnnotationLLMContextResponse, AnnotationUri, BaseUrl, CloneToken, ContentFormat, type DetectAnnotationsStreamRequest, type DetectionProgress, Email, EntityType, type GenerateResourceStreamRequest, type GenerationContext, type GenerationProgress, GoogleCredential, JobId, type Logger, type MimeCategory, Motivation, RefreshToken, ResourceAnnotationUri, ResourceUri, SSEClient, type SSEClientConfig, type SSEStream, SearchQuery, SemiontApiClient, type SemiontApiClientConfig, UserDID, components, getExtensionForMimeType, getMimeCategory, isImageMimeType, isPdfMimeType, isTextMimeType, paths };
+export { APIError, AccessToken, type AnnotationLLMContextResponse, AnnotationUri, BaseUrl, CloneToken, ContentFormat, type DetectReferencesStreamRequest, Email, EntityType, type GenerateResourceStreamRequest, type GenerationContext, type GenerationProgress, GoogleCredential, JobId, type Logger, type MimeCategory, Motivation, type ReferenceDetectionProgress, RefreshToken, type RequestOptions, ResourceAnnotationUri, ResourceUri, SSEClient, type SSEClientConfig, type SSEStream, SearchQuery, SemiontApiClient, type SemiontApiClientConfig, UserDID, components, getExtensionForMimeType, getMimeCategory, isImageMimeType, isPdfMimeType, isTextMimeType, paths };