@semiont/api-client 0.2.33-build.78 → 0.2.33-build.80

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-BjpP_lGG.js';
-export { $ as $defs, aN as AuthCode, av as BoundingBox, W as EventMetadata, F as FragmentSelector, aK as JWTTokenSchema, ab as LOCALES, aa as LocaleInfo, aO as MCPToken, au as Point, a5 as ResourceCreationDetails, X as ResourceEventType, i as Selector, V as StoredEvent, h as SvgSelector, a7 as TextPosition, T as TextPositionSelector, g as TextQuoteSelector, aD as ValidatedAnnotation, aI as ValidationFailure, aJ as ValidationResult, aH as ValidationSuccess, aS as accessToken, b0 as annotationUri, aQ as authCode, a_ as baseUrl, aV as cloneToken, ay as createCircleSvg, ax as createPolygonSvg, aw as createRectangleSvg, at as decodeRepresentation, aG as decodeWithCharset, aP as email, aY as entityType, Q as extractBoundingBox, aF as extractCharset, aC as extractContext, a8 as findTextWithContext, a0 as formatEventType, af as formatLocaleDisplay, a2 as formatRelativeTime, ag as getAllLocaleCodes, H as getAnnotationExactText, Y as getAnnotationUriFromEvent, j as getBodySource, k as getBodyType, ak as getChecksum, x as getCommentText, an as getCreator, ao as getDerivedFrom, a3 as getEventDisplayContent, a1 as getEventEmoji, a4 as getEventEntityTypes, D as getExactText, O as getFragmentSelector, al as getLanguage, ae as getLocaleEnglishName, ac as getLocaleInfo, ad as getLocaleNativeName, as as getNodeEncoding, aj as getPrimaryMediaType, ai as getPrimaryRepresentation, I as getPrimarySelector, a6 as getResourceCreationDetails, aq as getResourceEntityTypes, ah as getResourceId, am as getStorageUri, N as getSvgSelector, n as getTargetSelector, m as getTargetSource, K as getTextPositionSelector, L as getTextQuoteSelector, aR as googleCredential, q as hasTargetSelector, ap as isArchived, t as isAssessment, l as isBodyResolved, u as isComment, ar as isDraft, Z as isEventRelatedToAnnotation, r as isHighlight, s as isReference, z as isResolvedReference, _ as isResourceEvent, y as isStubReference, v as isTag, aM as isValidEmail, aW as jobId, aU as mcpToken, aA as normalizeCoordinates, o as operations, az as parseSvgSelector, aT as refreshToken, b1 as resourceAnnotationUri, a$ as resourceUri, aB as scaleSvgToNative, aZ as searchQuery, aX as userDID, aE as validateAndCorrectOffsets, aL as validateData, P as validateSvgMarkup, a9 as verifyPosition, w as webhooks } from './index-BjpP_lGG.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-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';
 
 /**
  * TypeScript types for Server-Sent Events (SSE) streaming
@@ -205,39 +205,18 @@ interface TagDetectionProgress {
  * as it occurs. Used for real-time collaboration - multiple users see each
  * other's changes as they happen.
  *
+ * Re-exported from @semiont/core (authoritative source).
+ * The discriminated union type provides type-safe event handling.
+ *
  * @example
  * ```typescript
- * stream.onEvent((event: ResourceEvent) => {
+ * stream.onEvent((event) => {
  *   console.log(`Event: ${event.type}`);
  *   console.log(`User: ${event.userId}`);
  *   console.log(`Payload:`, event.payload);
- *   console.log(`Sequence: ${event.metadata.sequenceNumber}`);
  * });
  * ```
  */
-interface ResourceEvent {
-    /** Event ID (unique) */
-    id: string;
-    /** Event type (e.g., 'resource.created', 'annotation.created', etc.) */
-    type: string;
-    /** ISO 8601 timestamp */
-    timestamp: string;
-    /** User ID who triggered the event */
-    userId: string;
-    /** Resource ID this event relates to */
-    resourceId: string;
-    /** Event-specific payload (varies by event type) */
-    payload: any;
-    /** Event store metadata */
-    metadata: {
-        /** Monotonically increasing sequence number */
-        sequenceNumber: number;
-        /** SHA-256 hash of previous event (for integrity) */
-        prevEventHash: string;
-        /** SHA-256 checksum of this event */
-        checksum: string;
-    };
-}
 /**
  * SSE stream controller interface
  *
@@ -374,25 +353,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(
  *   'http://localhost:4000/resources/doc-123',
- *   { entityTypes: ['Person', 'Organization'] }
+ *   { entityTypes: ['Person', 'Organization'] },
+ *   { auth: 'your-token' }
  * );
  *
  * stream.onProgress((p) => console.log(p.message));
@@ -402,17 +388,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
      */
@@ -432,13 +409,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(
      *   'http://localhost:4000/resources/doc-123',
-     *   { entityTypes: ['Person', 'Organization'] }
+     *   { entityTypes: ['Person', 'Organization'] },
+     *   { auth: 'your-token' }
      * );
      *
      * stream.onProgress((progress) => {
@@ -458,7 +437,7 @@ declare class SSEClient {
      * stream.close();
      * ```
      */
-    detectAnnotations(resourceId: ResourceUri, request: DetectAnnotationsStreamRequest): SSEStream<DetectionProgress, DetectionProgress>;
+    detectAnnotations(resourceId: ResourceUri, request: DetectAnnotationsStreamRequest, options?: SSERequestOptions): SSEStream<DetectionProgress, DetectionProgress>;
     /**
      * Generate resource from annotation (streaming)
      *
@@ -467,6 +446,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
@@ -474,7 +454,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) => {
@@ -494,7 +475,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)
      *
@@ -502,13 +483,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) => {
@@ -528,7 +511,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)
      *
@@ -536,13 +519,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) => {
@@ -562,7 +547,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)
      *
@@ -572,14 +557,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}%`);
@@ -597,7 +587,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)
      *
@@ -607,14 +597,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}%`);
@@ -633,7 +628,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)
      *
@@ -643,11 +638,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}`);
@@ -664,7 +663,7 @@ declare class SSEClient {
      * stream.close();
      * ```
      */
-    resourceEvents(resourceId: ResourceUri): SSEStream<ResourceEvent, never>;
+    resourceEvents(resourceId: ResourceUri, options?: SSERequestOptions): SSEStream<any, never>;
 }
 
 /**
@@ -710,20 +709,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
@@ -735,7 +740,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));
@@ -745,21 +751,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
      *
@@ -772,6 +770,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;
@@ -782,32 +781,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;
@@ -821,14 +821,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)
@@ -849,44 +850,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
@@ -897,15 +900,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']>>;
 }
 
 /**
@@ -980,4 +985,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, type ResourceEvent, 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 DetectAnnotationsStreamRequest, type DetectionProgress, Email, EntityType, type GenerateResourceStreamRequest, type GenerationContext, type GenerationProgress, GoogleCredential, JobId, type Logger, type MimeCategory, Motivation, RefreshToken, type RequestOptions, ResourceAnnotationUri, ResourceUri, SSEClient, type SSEClientConfig, type SSEStream, SearchQuery, SemiontApiClient, type SemiontApiClientConfig, UserDID, components, getExtensionForMimeType, getMimeCategory, isImageMimeType, isPdfMimeType, isTextMimeType, paths };