@nvisy/sdk 0.2.0 → 0.3.0

package/dist/index.js

@@ -3,7 +3,7 @@ import createClient from 'openapi-fetch';
 // src/client.ts
 
 // src/config.ts
-var VERSION = "0.2.0";
+var VERSION = "0.3.0";
 var DEFAULTS = {
   /**
    * Default base URL for the Nvisy API.
@@ -16,7 +16,25 @@ var DEFAULTS = {
 };
 
 // src/errors.ts
-var ApiError = class extends Error {
+var NvisyError = class extends Error {
+  /**
+   * The error class name.
+   */
+  name;
+  /**
+   * Creates a new NvisyError.
+   *
+   * @param message - The error message
+   */
+  constructor(message) {
+    super(message);
+    this.name = this.constructor.name;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+};
+var NvisyApiError = class extends NvisyError {
   /**
    * The error type identifier (e.g., "ValidationError", "NotFoundError").
    */
@@ -39,13 +57,13 @@ var ApiError = class extends Error {
    * Field-specific validation errors.
    * Present when the error is due to invalid input data.
    */
-  validationErrors;
+  validation;
   /**
    * HTTP status code of the response (e.g., 400, 404, 500).
    */
   statusCode;
   /**
-   * Creates a new ApiError from an API error response.
+   * Creates a new NvisyApiError from an API error response.
    *
    * @param response - The error response from the API
    * @param statusCode - The HTTP status code of the response
@@ -56,7 +74,7 @@ var ApiError = class extends Error {
     this.message = response.message;
     this.resource = response.resource;
     this.suggestion = response.suggestion;
-    this.validationErrors = response.validationErrors;
+    this.validation = response.validation;
     this.statusCode = statusCode;
     if (Error.captureStackTrace) {
       Error.captureStackTrace(this, this.constructor);
@@ -110,157 +128,69 @@ var ApiError = class extends Error {
       message: this.message,
       resource: this.resource,
       suggestion: this.suggestion,
-      validationErrors: this.validationErrors
+      validation: this.validation
     };
   }
 };
-var ClientError = class extends Error {
-  /**
-   * The error class name (e.g., "ConfigError", "NetworkError").
-   */
-  name;
-  /**
-   * Creates a new ClientError.
-   *
-   * @param message - The error message
-   */
-  constructor(message) {
-    super(message);
-    this.name = this.constructor.name;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, this.constructor);
-    }
-  }
-};
-var ConfigError = class _ConfigError extends ClientError {
-  /**
-   * The configuration field that caused the error.
-   * May be undefined for general configuration errors.
-   */
-  field;
-  /**
-   * A description of why the configuration is invalid.
-   * May be undefined for simple errors.
-   */
-  reason;
-  /**
-   * Creates a new ConfigError.
-   *
-   * @param message - The error message
-   * @param options - Additional error context
-   * @param options.field - The field that caused the error
-   * @param options.reason - Why the configuration is invalid
-   */
-  constructor(message, options) {
-    super(message);
-    this.field = options?.field;
-    this.reason = options?.reason;
-  }
-  /**
-   * Creates a ConfigError for a missing API token.
-   *
-   * @returns A ConfigError indicating the API token is required
-   *
-   * @internal
-   */
-  static missingApiToken() {
-    return new _ConfigError("API token is required", {
-      field: "apiToken",
-      reason: "API token must be provided in configuration"
-    });
-  }
-  /**
-   * Creates a ConfigError for an invalid configuration field.
-   *
-   * @param field - The name of the invalid field
-   * @param reason - Why the field value is invalid
-   * @returns A ConfigError with field and reason context
-   *
-   * @internal
-   */
-  static invalidField(field, reason) {
-    return new _ConfigError(`Invalid configuration for ${field}: ${reason}`, {
-      field,
-      reason
-    });
-  }
-  /**
-   * Creates a ConfigError for a missing required field.
-   *
-   * @param field - The name of the missing field
-   * @returns A ConfigError indicating the field is required
-   *
-   * @internal
-   */
-  static missingField(field) {
-    return new _ConfigError(`Missing required configuration field: ${field}`, {
-      field,
-      reason: "This field is required"
-    });
-  }
-};
-var NetworkError = class _NetworkError extends ClientError {
-  /**
-   * The underlying error that caused this network error.
-   * May be undefined if no underlying error is available.
-   */
-  cause;
-  /**
-   * Creates a new NetworkError.
-   *
-   * @param message - The error message
-   * @param cause - The underlying error that caused this failure
-   */
-  constructor(message, cause) {
-    super(message);
-    this.cause = cause;
-  }
-  /**
-   * Creates a NetworkError for connection issues.
-   *
-   * @param message - Description of the connection problem
-   * @param cause - The underlying error
-   * @returns A NetworkError for connection failures
-   *
-   * @internal
-   */
-  static connection(message, cause) {
-    return new _NetworkError(message, cause);
-  }
-  /**
-   * Creates a NetworkError for aborted requests.
-   *
-   * @returns A NetworkError indicating the request was aborted
-   *
-   * @internal
-   */
-  static aborted() {
-    return new _NetworkError("Request was aborted");
-  }
-};
 
 // src/middleware/error.ts
 var errorMiddleware = {
   async onResponse({ response }) {
     if (!response.ok) {
       const error = await response.clone().json();
-      throw new ApiError(error, response.status);
+      throw new NvisyApiError(error, response.status);
     }
     return response;
   },
   onError({ error }) {
     if (error instanceof Error) {
-      if (error.name === "AbortError") {
-        throw NetworkError.aborted();
-      }
-      throw NetworkError.connection(error.message, error);
+      throw new NvisyError(error.message);
     }
-    throw NetworkError.connection("An unknown network error occurred");
+    throw new NvisyError("An unknown network error occurred");
   }
 };
 
+// src/middleware/logging.ts
+function createLoggingMiddleware() {
+  return {
+    async onRequest({ request }) {
+      const start = performance.now();
+      request._startTime = start;
+      return request;
+    },
+    async onResponse({ request, response }) {
+      const start = request._startTime ?? performance.now();
+      const duration = Math.round(performance.now() - start);
+      const url = new URL(request.url);
+      console.log(
+        `[nvisy] ${request.method} ${url.pathname} ${response.status} (${duration}ms)`
+      );
+      if (!response.ok) {
+        const cloned = response.clone();
+        try {
+          const body = await cloned.json();
+          console.error("[nvisy] Response:", JSON.stringify(body, null, 2));
+        } catch {
+          const text = await cloned.text();
+          if (text) console.error("[nvisy] Response:", text);
+        }
+      }
+      return response;
+    },
+    onError({ request, error }) {
+      const start = request._startTime ?? performance.now();
+      const duration = Math.round(performance.now() - start);
+      const url = new URL(request.url);
+      console.error(
+        `[nvisy] ${request.method} ${url.pathname} ERROR (${duration}ms):`,
+        error instanceof Error ? error.message : error
+      );
+    }
+  };
+}
+
 // src/services/account.ts
-var AccountService = class {
+var Account = class {
   #api;
   constructor(api) {
     this.#api = api;
@@ -270,7 +200,7 @@ var AccountService = class {
    * @returns Promise that resolves with the account details
    * @throws {ApiError} if the request fails
    */
-  async get() {
+  async getAccount() {
     const { data } = await this.#api.GET("/account");
     return data;
   }
@@ -280,7 +210,7 @@ var AccountService = class {
    * @returns Promise that resolves with the updated account
    * @throws {ApiError} if the request fails
    */
-  async update(updates) {
+  async updateAccount(updates) {
     const { data } = await this.#api.PATCH("/account", {
       body: updates
     });
@@ -291,13 +221,13 @@ var AccountService = class {
    * @returns Promise that resolves when the account is deleted
    * @throws {ApiError} if the request fails
    */
-  async delete() {
+  async deleteAccount() {
     await this.#api.DELETE("/account");
   }
 };
 
 // src/services/activities.ts
-var ActivitiesService = class {
+var Activities = class {
   #api;
   constructor(api) {
     this.#api = api;
@@ -305,13 +235,13 @@ var ActivitiesService = class {
   /**
    * List activities for a workspace
    * @param workspaceId - Workspace ID
-   * @param query - Optional query parameters (offset, limit)
-   * @returns Promise that resolves with the list of activities
+   * @param query - Optional pagination parameters (limit, after)
+   * @returns Promise that resolves with a paginated list of activities
    * @throws {ApiError} if the request fails
    */
-  async list(workspaceId, query) {
+  async listActivities(workspaceId, query) {
     const { data } = await this.#api.GET(
-      "/workspaces/{workspace_id}/activities/",
+      "/workspaces/{workspaceId}/activities/",
       {
         params: { path: { workspaceId }, query }
       }
@@ -321,7 +251,7 @@ var ActivitiesService = class {
 };
 
 // src/services/annotations.ts
-var AnnotationsService = class {
+var Annotations = class {
   #api;
   constructor(api) {
     this.#api = api;
@@ -329,12 +259,12 @@ var AnnotationsService = class {
   /**
    * List annotations for a file
    * @param fileId - File ID
-   * @param query - Optional query parameters (offset, limit)
-   * @returns Promise that resolves with the list of annotations
+   * @param query - Optional pagination parameters (limit, after)
+   * @returns Promise that resolves with a paginated list of annotations
    * @throws {ApiError} if the request fails
    */
-  async list(fileId, query) {
-    const { data } = await this.#api.GET("/files/{file_id}/annotations/", {
+  async listAnnotations(fileId, query) {
+    const { data } = await this.#api.GET("/files/{fileId}/annotations/", {
       params: { path: { fileId }, query }
     });
     return data;
@@ -345,8 +275,8 @@ var AnnotationsService = class {
    * @returns Promise that resolves with the annotation details
    * @throws {ApiError} if the request fails
    */
-  async get(annotationId) {
-    const { data } = await this.#api.GET("/annotations/{annotation_id}", {
+  async getAnnotation(annotationId) {
+    const { data } = await this.#api.GET("/annotations/{annotationId}", {
       params: { path: { annotationId } }
     });
     return data;
@@ -358,8 +288,8 @@ var AnnotationsService = class {
    * @returns Promise that resolves with the created annotation
    * @throws {ApiError} if the request fails
    */
-  async create(fileId, annotation) {
-    const { data } = await this.#api.POST("/files/{file_id}/annotations/", {
+  async createAnnotation(fileId, annotation) {
+    const { data } = await this.#api.POST("/files/{fileId}/annotations/", {
       params: { path: { fileId } },
       body: annotation
     });
@@ -372,8 +302,8 @@ var AnnotationsService = class {
    * @returns Promise that resolves with the updated annotation
    * @throws {ApiError} if the request fails
    */
-  async update(annotationId, updates) {
-    const { data } = await this.#api.PATCH("/annotations/{annotation_id}", {
+  async updateAnnotation(annotationId, updates) {
+    const { data } = await this.#api.PATCH("/annotations/{annotationId}", {
       params: { path: { annotationId } },
       body: updates
     });
@@ -385,53 +315,50 @@ var AnnotationsService = class {
    * @returns Promise that resolves when the annotation is deleted
    * @throws {ApiError} if the request fails
    */
-  async delete(annotationId) {
-    await this.#api.DELETE("/annotations/{annotation_id}", {
+  async deleteAnnotation(annotationId) {
+    await this.#api.DELETE("/annotations/{annotationId}", {
       params: { path: { annotationId } }
     });
   }
 };
 
 // src/services/api-tokens.ts
-var ApiTokensService = class {
+var ApiTokens = class {
   #api;
   constructor(api) {
     this.#api = api;
   }
   /**
    * List all API tokens for the authenticated account
-   * @param options - Pagination options
-   * @returns Promise that resolves with the list of API tokens
+   * @param query - Optional pagination parameters (limit, after)
+   * @returns Promise that resolves with a paginated list of API tokens
    * @throws {ApiError} if the request fails
    */
-  async list(options) {
+  async listApiTokens(query) {
     const { data } = await this.#api.GET("/api-tokens/", {
-      params: { query: options }
+      params: { query }
     });
     return data;
   }
   /**
-   * Get a specific API token by access token
-   * @param accessToken - The access token identifier
+   * Get a specific API token by token ID
+   * @param tokenId - The token identifier
    * @returns Promise that resolves with the API token details
    * @throws {ApiError} if the request fails
    */
-  async get(accessToken) {
-    const { data } = await this.#api.GET(
-      "/api-tokens/{access_token}/",
-      {
-        params: { path: { access_token: accessToken } }
-      }
-    );
+  async getApiToken(tokenId) {
+    const { data } = await this.#api.GET("/api-tokens/{tokenId}/", {
+      params: { path: { tokenId } }
+    });
     return data;
   }
   /**
    * Create a new API token
    * @param token - Token creation request
-   * @returns Promise that resolves with the created token (includes secret, shown only once)
+   * @returns Promise that resolves with the created token (includes JWT, shown only once)
    * @throws {ApiError} if the request fails
    */
-  async create(token) {
+  async createApiToken(token) {
     const { data } = await this.#api.POST("/api-tokens/", {
       body: token
     });
@@ -439,39 +366,33 @@ var ApiTokensService = class {
   }
   /**
    * Update an existing API token
-   * @param accessToken - The access token identifier
+   * @param tokenId - The token identifier
    * @param updates - Token update request
    * @returns Promise that resolves with the updated token
    * @throws {ApiError} if the request fails
    */
-  async update(accessToken, updates) {
-    const { data } = await this.#api.PATCH(
-      "/api-tokens/{access_token}/",
-      {
-        params: { path: { access_token: accessToken } },
-        body: updates
-      }
-    );
+  async updateApiToken(tokenId, updates) {
+    const { data } = await this.#api.PATCH("/api-tokens/{tokenId}/", {
+      params: { path: { tokenId } },
+      body: updates
+    });
     return data;
   }
   /**
    * Revoke an API token
-   * @param accessToken - The access token identifier
+   * @param tokenId - The token identifier
    * @returns Promise that resolves when the token is revoked
    * @throws {ApiError} if the request fails
    */
-  async revoke(accessToken) {
-    await this.#api.DELETE(
-      "/api-tokens/{access_token}/",
-      {
-        params: { path: { access_token: accessToken } }
-      }
-    );
+  async revokeApiToken(tokenId) {
+    await this.#api.DELETE("/api-tokens/{tokenId}/", {
+      params: { path: { tokenId } }
+    });
   }
 };
 
 // src/services/auth.ts
-var AuthService = class {
+var Auth = class {
   #api;
   constructor(api) {
     this.#api = api;
@@ -482,7 +403,7 @@ var AuthService = class {
    * @returns Promise that resolves with the auth response containing access token
    * @throws {ApiError} if the request fails
    */
-  async login(credentials) {
+  async loginAccount(credentials) {
     const { data } = await this.#api.POST("/auth/login", {
       body: credentials
     });
@@ -490,20 +411,28 @@ var AuthService = class {
   }
   /**
    * Sign up a new account
-   * @param details - Signup details
+   * @param credentials - Signup details
    * @returns Promise that resolves with the auth response containing access token
    * @throws {ApiError} if the request fails
    */
-  async signup(details) {
+  async signupAccount(credentials) {
     const { data } = await this.#api.POST("/auth/signup", {
-      body: details
+      body: credentials
     });
     return data;
   }
+  /**
+   * Logout and invalidate the current access token
+   * @returns Promise that resolves when logout is complete
+   * @throws {ApiError} if the request fails
+   */
+  async logoutAccount() {
+    await this.#api.POST("/auth/logout");
+  }
 };
 
 // src/services/comments.ts
-var CommentsService = class {
+var Comments = class {
   #api;
   constructor(api) {
     this.#api = api;
@@ -511,12 +440,12 @@ var CommentsService = class {
   /**
    * List all comments on a file
    * @param fileId - File ID
-   * @param query - Optional query parameters (offset, limit)
-   * @returns Promise that resolves with the list of comments
+   * @param query - Optional pagination parameters (limit, after)
+   * @returns Promise that resolves with a paginated list of comments
    * @throws {ApiError} if the request fails
    */
-  async list(fileId, query) {
-    const { data } = await this.#api.GET("/files/{file_id}/comments", {
+  async listComments(fileId, query) {
+    const { data } = await this.#api.GET("/files/{fileId}/comments", {
       params: { path: { fileId }, query }
     });
     return data;
@@ -528,29 +457,42 @@ var CommentsService = class {
    * @returns Promise that resolves with the created comment
    * @throws {ApiError} if the request fails
    */
-  async create(fileId, comment) {
-    const { data } = await this.#api.POST("/files/{file_id}/comments", {
+  async createComment(fileId, comment) {
+    const { data } = await this.#api.POST("/files/{fileId}/comments", {
       params: { path: { fileId } },
       body: comment
     });
     return data;
   }
+  /**
+   * Update a comment
+   * @param commentId - Comment ID
+   * @param updates - Comment update request
+   * @returns Promise that resolves with the updated comment
+   * @throws {ApiError} if the request fails
+   */
+  async updateComment(commentId, updates) {
+    const { data } = await this.#api.PATCH("/comments/{commentId}", {
+      params: { path: { commentId } },
+      body: updates
+    });
+    return data;
+  }
   /**
    * Delete a comment
-   * @param fileId - File ID
    * @param commentId - Comment ID
    * @returns Promise that resolves when the comment is deleted
    * @throws {ApiError} if the request fails
    */
-  async delete(fileId, commentId) {
-    await this.#api.DELETE("/files/{file_id}/comments/{comment_id}", {
-      params: { path: { fileId, commentId } }
+  async deleteComment(commentId) {
+    await this.#api.DELETE("/comments/{commentId}", {
+      params: { path: { commentId } }
     });
   }
 };
 
 // src/services/documents.ts
-var DocumentsService = class {
+var Documents = class {
   #api;
   constructor(api) {
     this.#api = api;
@@ -558,13 +500,13 @@ var DocumentsService = class {
   /**
    * List documents in a workspace
    * @param workspaceId - Workspace ID
-   * @param query - Optional query parameters (offset, limit)
-   * @returns Promise that resolves with the list of documents
+   * @param query - Optional pagination parameters (limit, after)
+   * @returns Promise that resolves with a paginated list of documents
    * @throws {ApiError} if the request fails
    */
-  async list(workspaceId, query) {
+  async listDocuments(workspaceId, query) {
     const { data } = await this.#api.GET(
-      "/workspaces/{workspace_id}/documents",
+      "/workspaces/{workspaceId}/documents",
       {
         params: { path: { workspaceId }, query }
       }
@@ -577,8 +519,8 @@ var DocumentsService = class {
    * @returns Promise that resolves with the document details
    * @throws {ApiError} if the request fails
    */
-  async get(documentId) {
-    const { data } = await this.#api.GET("/documents/{document_id}", {
+  async getDocument(documentId) {
+    const { data } = await this.#api.GET("/documents/{documentId}", {
       params: { path: { documentId } }
     });
     return data;
@@ -590,9 +532,9 @@ var DocumentsService = class {
    * @returns Promise that resolves with the created document
    * @throws {ApiError} if the request fails
    */
-  async create(workspaceId, document) {
+  async createDocument(workspaceId, document) {
     const { data } = await this.#api.POST(
-      "/workspaces/{workspace_id}/documents",
+      "/workspaces/{workspaceId}/documents",
       {
         params: { path: { workspaceId } },
         body: document
@@ -607,8 +549,8 @@ var DocumentsService = class {
    * @returns Promise that resolves with the updated document
    * @throws {ApiError} if the request fails
    */
-  async update(documentId, updates) {
-    const { data } = await this.#api.PATCH("/documents/{document_id}", {
+  async updateDocument(documentId, updates) {
+    const { data } = await this.#api.PATCH("/documents/{documentId}", {
       params: { path: { documentId } },
       body: updates
     });
@@ -620,40 +562,76 @@ var DocumentsService = class {
    * @returns Promise that resolves when the document is deleted
    * @throws {ApiError} if the request fails
    */
-  async delete(documentId) {
-    await this.#api.DELETE("/documents/{document_id}", {
+  async deleteDocument(documentId) {
+    await this.#api.DELETE("/documents/{documentId}", {
       params: { path: { documentId } }
     });
   }
 };
 
 // src/services/files.ts
-var FilesService = class {
+var Files = class {
   #api;
   constructor(api) {
     this.#api = api;
   }
+  /**
+   * Upload one or more files to a workspace
+   * @param workspaceId - Workspace ID
+   * @param files - File or array of files to upload
+   * @returns Promise that resolves with the uploaded file metadata
+   * @throws {ApiError} if the request fails
+   */
+  async uploadFiles(workspaceId, files) {
+    const formData = new FormData();
+    const fileArray = Array.isArray(files) ? files : [files];
+    for (const file of fileArray) {
+      const name = file instanceof File ? file.name : "file";
+      formData.append("files", file, name);
+    }
+    const { data } = await this.#api.POST("/workspaces/{workspaceId}/files/", {
+      params: { path: { workspaceId } },
+      // Schema types multipart as unknown[], but openapi-fetch needs FormData.
+      body: formData,
+      bodySerializer: (formData2) => formData2,
+      // Remove Content-Type so browser sets multipart/form-data with boundary.
+      headers: { "Content-Type": null }
+    });
+    return data;
+  }
   /**
    * List files in a workspace
    * @param workspaceId - Workspace ID
-   * @param query - Optional query parameters (formats, sortBy, order, offset, limit)
-   * @returns Promise that resolves with the list of files
+   * @param query - Optional query parameters (formats, limit, after)
+   * @returns Promise that resolves with a paginated list of files
    * @throws {ApiError} if the request fails
    */
-  async list(workspaceId, query) {
-    const { data } = await this.#api.GET("/workspaces/{workspace_id}/files/", {
+  async listFiles(workspaceId, query) {
+    const { data } = await this.#api.GET("/workspaces/{workspaceId}/files/", {
       params: { path: { workspaceId }, query }
     });
     return data;
   }
+  /**
+   * Get file metadata by ID
+   * @param fileId - File ID
+   * @returns Promise that resolves with the file metadata
+   * @throws {ApiError} if the request fails
+   */
+  async getFile(fileId) {
+    const { data } = await this.#api.GET("/files/{fileId}", {
+      params: { path: { fileId } }
+    });
+    return data;
+  }
   /**
    * Download a file by ID
    * @param fileId - File ID
    * @returns Promise that resolves with the file response
    * @throws {ApiError} if the request fails
    */
-  async download(fileId) {
-    const { response } = await this.#api.GET("/files/{file_id}", {
+  async downloadFile(fileId) {
+    const { response } = await this.#api.GET("/files/{fileId}/content", {
       params: { path: { fileId } },
       parseAs: "stream"
     });
@@ -666,8 +644,8 @@ var FilesService = class {
    * @returns Promise that resolves with the updated file
    * @throws {ApiError} if the request fails
    */
-  async update(fileId, updates) {
-    const { data } = await this.#api.PATCH("/files/{file_id}", {
+  async updateFile(fileId, updates) {
+    const { data } = await this.#api.PATCH("/files/{fileId}", {
       params: { path: { fileId } },
       body: updates
     });
@@ -679,21 +657,21 @@ var FilesService = class {
    * @returns Promise that resolves when the file is deleted
    * @throws {ApiError} if the request fails
    */
-  async delete(fileId) {
-    await this.#api.DELETE("/files/{file_id}", {
+  async deleteFile(fileId) {
+    await this.#api.DELETE("/files/{fileId}", {
       params: { path: { fileId } }
     });
   }
   /**
-   * Download multiple files
+   * Download files as an archive
    * @param workspaceId - Workspace ID
-   * @param request - Download request with file IDs
-   * @returns Promise that resolves with the download response
+   * @param request - Download request with format and optional file IDs
+   * @returns Promise that resolves with the archive response
    * @throws {ApiError} if the request fails
    */
-  async downloadMultiple(workspaceId, request) {
-    const { response } = await this.#api.POST(
-      "/workspaces/{workspace_id}/files/download",
+  async downloadFiles(workspaceId, request) {
+    const { response } = await this.#api.GET(
+      "/workspaces/{workspaceId}/files/batch",
       {
         params: { path: { workspaceId } },
         body: request,
@@ -703,27 +681,22 @@ var FilesService = class {
     return response;
   }
   /**
-   * Download files as an archive
+   * Delete multiple files
    * @param workspaceId - Workspace ID
-   * @param request - Archive download request
-   * @returns Promise that resolves with the archive response
+   * @param request - Delete request with file IDs
+   * @returns Promise that resolves when the files are deleted
    * @throws {ApiError} if the request fails
    */
-  async downloadArchive(workspaceId, request) {
-    const { response } = await this.#api.POST(
-      "/workspaces/{workspace_id}/files/archive",
-      {
-        params: { path: { workspaceId } },
-        body: request,
-        parseAs: "stream"
-      }
-    );
-    return response;
+  async deleteFiles(workspaceId, request) {
+    await this.#api.DELETE("/workspaces/{workspaceId}/files/batch", {
+      params: { path: { workspaceId } },
+      body: request
+    });
   }
 };
 
 // src/services/integrations.ts
-var IntegrationsService = class {
+var Integrations = class {
   #api;
   constructor(api) {
     this.#api = api;
@@ -731,13 +704,13 @@ var IntegrationsService = class {
   /**
    * List integrations for a workspace
    * @param workspaceId - Workspace ID
-   * @param query - Optional query parameters (integrationType, offset, limit)
-   * @returns Promise that resolves with the list of integrations
+   * @param query - Optional pagination parameters (limit, after)
+   * @returns Promise that resolves with a paginated list of integrations
    * @throws {ApiError} if the request fails
    */
-  async list(workspaceId, query) {
+  async listIntegrations(workspaceId, query) {
     const { data } = await this.#api.GET(
-      "/workspaces/{workspace_id}/integrations/",
+      "/workspaces/{workspaceId}/integrations/",
       {
         params: { path: { workspaceId }, query }
       }
@@ -750,8 +723,8 @@ var IntegrationsService = class {
    * @returns Promise that resolves with the integration details
    * @throws {ApiError} if the request fails
    */
-  async get(integrationId) {
-    const { data } = await this.#api.GET("/integrations/{integration_id}/", {
+  async getIntegration(integrationId) {
+    const { data } = await this.#api.GET("/integrations/{integrationId}/", {
       params: { path: { integrationId } }
     });
     return data;
@@ -763,9 +736,9 @@ var IntegrationsService = class {
    * @returns Promise that resolves with the created integration
    * @throws {ApiError} if the request fails
    */
-  async create(workspaceId, integration) {
+  async createIntegration(workspaceId, integration) {
     const { data } = await this.#api.POST(
-      "/workspaces/{workspace_id}/integrations/",
+      "/workspaces/{workspaceId}/integrations/",
       {
         params: { path: { workspaceId } },
         body: integration
@@ -780,8 +753,8 @@ var IntegrationsService = class {
    * @returns Promise that resolves with the updated integration
    * @throws {ApiError} if the request fails
    */
-  async update(integrationId, updates) {
-    const { data } = await this.#api.PUT("/integrations/{integration_id}/", {
+  async updateIntegration(integrationId, updates) {
+    const { data } = await this.#api.PUT("/integrations/{integrationId}/", {
       params: { path: { integrationId } },
       body: updates
     });
@@ -794,9 +767,9 @@ var IntegrationsService = class {
    * @returns Promise that resolves with the updated integration
    * @throws {ApiError} if the request fails
    */
-  async updateCredentials(integrationId, credentials) {
+  async updateIntegrationCredentials(integrationId, credentials) {
     const { data } = await this.#api.PATCH(
-      "/integrations/{integration_id}/credentials/",
+      "/integrations/{integrationId}/credentials/",
       {
         params: { path: { integrationId } },
         body: credentials
@@ -810,15 +783,15 @@ var IntegrationsService = class {
    * @returns Promise that resolves when the integration is deleted
    * @throws {ApiError} if the request fails
    */
-  async delete(integrationId) {
-    await this.#api.DELETE("/integrations/{integration_id}/", {
+  async deleteIntegration(integrationId) {
+    await this.#api.DELETE("/integrations/{integrationId}/", {
       params: { path: { integrationId } }
     });
   }
 };
 
 // src/services/invites.ts
-var InvitesService = class {
+var Invites = class {
   #api;
   constructor(api) {
     this.#api = api;
@@ -826,17 +799,14 @@ var InvitesService = class {
   /**
    * List all invitations for a workspace
    * @param workspaceId - Workspace ID
-   * @param query - Optional query parameters (role, sortBy, order, offset, limit)
-   * @returns Promise that resolves with the list of invitations
+   * @param query - Optional query parameters (role, sortBy, order, limit, after)
+   * @returns Promise that resolves with a paginated list of invitations
    * @throws {ApiError} if the request fails
    */
-  async list(workspaceId, query) {
-    const { data } = await this.#api.GET(
-      "/workspaces/{workspace_id}/invites/",
-      {
-        params: { path: { workspaceId }, query }
-      }
-    );
+  async listInvites(workspaceId, query) {
+    const { data } = await this.#api.GET("/workspaces/{workspaceId}/invites/", {
+      params: { path: { workspaceId }, query }
+    });
     return data;
   }
   /**
@@ -846,9 +816,9 @@ var InvitesService = class {
    * @returns Promise that resolves with the created invitation
    * @throws {ApiError} if the request fails
    */
-  async send(workspaceId, invite) {
+  async sendInvite(workspaceId, invite) {
     const { data } = await this.#api.POST(
-      "/workspaces/{workspace_id}/invites/",
+      "/workspaces/{workspaceId}/invites/",
       {
         params: { path: { workspaceId } },
         body: invite
@@ -862,8 +832,8 @@ var InvitesService = class {
    * @returns Promise that resolves when the invitation is canceled
    * @throws {ApiError} if the request fails
    */
-  async cancel(inviteId) {
-    await this.#api.DELETE("/invites/{invite_id}/", {
+  async cancelInvite(inviteId) {
+    await this.#api.DELETE("/invites/{inviteId}/", {
       params: { path: { inviteId } }
     });
   }
@@ -874,8 +844,8 @@ var InvitesService = class {
    * @returns Promise that resolves with the updated invitation
    * @throws {ApiError} if the request fails
    */
-  async reply(inviteId, reply) {
-    const { data } = await this.#api.PATCH("/invites/{invite_id}/reply/", {
+  async replyToInvite(inviteId, reply) {
+    const { data } = await this.#api.POST("/invites/{inviteId}/", {
       params: { path: { inviteId } },
       body: reply
     });
@@ -888,9 +858,9 @@ var InvitesService = class {
    * @returns Promise that resolves with the generated invite code
    * @throws {ApiError} if the request fails
    */
-  async generateCode(workspaceId, options) {
+  async generateInviteCode(workspaceId, options) {
     const { data } = await this.#api.POST(
-      "/workspaces/{workspace_id}/invites/code/",
+      "/workspaces/{workspaceId}/invites/code/",
       {
         params: { path: { workspaceId } },
         body: options
@@ -899,13 +869,27 @@ var InvitesService = class {
     return data;
   }
   /**
-   * Join a workspace using an invite code
+   * Reply to an invite code (accept or decline)
    * @param inviteCode - The invite code
-   * @returns Promise that resolves with the member details
+   * @param reply - Optional reply request (defaults to accept if not provided)
+   * @returns Promise that resolves with the member details if accepted, null if declined
    * @throws {ApiError} if the request fails
    */
-  async joinWithCode(inviteCode) {
-    const { data } = await this.#api.POST("/invites/{invite_code}/join/", {
+  async replyToInviteCode(inviteCode, reply) {
+    const { data } = await this.#api.POST("/invites/code/{inviteCode}/", {
+      params: { path: { inviteCode } },
+      body: reply ?? null
+    });
+    return data;
+  }
+  /**
+   * Preview an invite code without joining
+   * @param inviteCode - The invite code
+   * @returns Promise that resolves with the invite preview details
+   * @throws {ApiError} if the request fails
+   */
+  async previewInvite(inviteCode) {
+    const { data } = await this.#api.GET("/invites/code/{inviteCode}/", {
       params: { path: { inviteCode } }
     });
     return data;
@@ -913,7 +897,7 @@ var InvitesService = class {
 };
 
 // src/services/members.ts
-var MembersService = class {
+var Members = class {
   #api;
   constructor(api) {
     this.#api = api;
@@ -921,17 +905,14 @@ var MembersService = class {
   /**
    * List members of a workspace
    * @param workspaceId - Workspace ID
-   * @param query - Optional query parameters (role, has2fa, sortBy, order, offset, limit)
-   * @returns Promise that resolves with the list of members
+   * @param query - Optional query parameters (role, has2fa, sortBy, order, limit, after)
+   * @returns Promise that resolves with a paginated list of members
    * @throws {ApiError} if the request fails
    */
-  async list(workspaceId, query) {
-    const { data } = await this.#api.GET(
-      "/workspaces/{workspace_id}/members/",
-      {
-        params: { path: { workspaceId }, query }
-      }
-    );
+  async listMembers(workspaceId, query) {
+    const { data } = await this.#api.GET("/workspaces/{workspaceId}/members/", {
+      params: { path: { workspaceId }, query }
+    });
     return data;
   }
   /**
@@ -941,11 +922,13 @@ var MembersService = class {
    * @returns Promise that resolves with the member details
    * @throws {ApiError} if the request fails
    */
-  async get(workspaceId, accountId) {
+  async getMember(workspaceId, accountId) {
     const { data } = await this.#api.GET(
-      "/workspaces/{workspace_id}/members/{account_id}/",
+      "/workspaces/{workspaceId}/members/{accountId}/",
       {
-        params: { path: { workspaceId, accountId } }
+        params: {
+          path: { workspaceId, accountId }
+        }
       }
     );
     return data;
@@ -954,16 +937,18 @@ var MembersService = class {
    * Update a member's role
    * @param workspaceId - Workspace ID
    * @param accountId - Account ID
-   * @param role - New role for the member
+   * @param updates - New role for the member
    * @returns Promise that resolves with the updated member
    * @throws {ApiError} if the request fails
    */
-  async updateRole(workspaceId, accountId, role) {
+  async updateMember(workspaceId, accountId, updates) {
     const { data } = await this.#api.PATCH(
-      "/workspaces/{workspace_id}/members/{account_id}/role",
+      "/workspaces/{workspaceId}/members/{accountId}/role",
       {
-        params: { path: { workspaceId, accountId } },
-        body: role
+        params: {
+          path: { workspaceId, accountId }
+        },
+        body: updates
       }
     );
     return data;
@@ -975,8 +960,8 @@ var MembersService = class {
    * @returns Promise that resolves when the member is removed
    * @throws {ApiError} if the request fails
    */
-  async remove(workspaceId, accountId) {
-    await this.#api.DELETE("/workspaces/{workspace_id}/members/{account_id}/", {
+  async removeMember(workspaceId, accountId) {
+    await this.#api.DELETE("/workspaces/{workspaceId}/members/{accountId}/", {
       params: { path: { workspaceId, accountId } }
     });
   }
@@ -986,35 +971,44 @@ var MembersService = class {
    * @returns Promise that resolves when the member has left
    * @throws {ApiError} if the request fails
    */
-  async leave(workspaceId) {
-    await this.#api.POST("/workspaces/{workspace_id}/members/leave", {
+  async leaveWorkspace(workspaceId) {
+    await this.#api.POST("/workspaces/{workspaceId}/members/leave", {
       params: { path: { workspaceId } }
     });
   }
 };
 
 // src/services/notifications.ts
-var NotificationsService = class {
+var Notifications = class {
   #api;
   constructor(api) {
     this.#api = api;
   }
   /**
    * List notifications for the authenticated account
-   * @param query - Optional query parameters (offset, limit)
-   * @returns Promise that resolves with the list of notifications
+   * @param query - Optional pagination parameters (limit, after)
+   * @returns Promise that resolves with a paginated list of notifications
    * @throws {ApiError} if the request fails
    */
-  async list(query) {
+  async listNotifications(query) {
     const { data } = await this.#api.GET("/notifications/", {
       params: { query }
     });
     return data;
   }
+  /**
+   * Get the unread notifications count for the authenticated account
+   * @returns Promise that resolves with the unread status
+   * @throws {ApiError} if the request fails
+   */
+  async getUnreadNotificationsStatus() {
+    const { data } = await this.#api.GET("/notifications/unread");
+    return data;
+  }
 };
 
 // src/services/runs.ts
-var RunsService = class {
+var Runs = class {
   #api;
   constructor(api) {
     this.#api = api;
@@ -1022,12 +1016,12 @@ var RunsService = class {
   /**
    * List integration runs for a workspace
    * @param workspaceId - Workspace ID
-   * @param query - Optional query parameters (offset, limit)
-   * @returns Promise that resolves with the list of integration runs
+   * @param query - Optional pagination parameters (limit, after)
+   * @returns Promise that resolves with a paginated list of integration runs
    * @throws {ApiError} if the request fails
    */
-  async list(workspaceId, query) {
-    const { data } = await this.#api.GET("/workspaces/{workspace_id}/runs/", {
+  async listRuns(workspaceId, query) {
+    const { data } = await this.#api.GET("/workspaces/{workspaceId}/runs/", {
       params: { path: { workspaceId }, query }
     });
     return data;
@@ -1038,8 +1032,8 @@ var RunsService = class {
    * @returns Promise that resolves with the integration run details
    * @throws {ApiError} if the request fails
    */
-  async get(runId) {
-    const { data } = await this.#api.GET("/runs/{run_id}", {
+  async getRun(runId) {
+    const { data } = await this.#api.GET("/runs/{runId}", {
       params: { path: { runId } }
     });
     return data;
@@ -1047,7 +1041,7 @@ var RunsService = class {
 };
 
 // src/services/status.ts
-var StatusService = class {
+var Status = class {
   #api;
   constructor(api) {
     this.#api = api;
@@ -1057,7 +1051,7 @@ var StatusService = class {
    * @param options - Health check options
    * @returns Promise that resolves with the API health status
    */
-  async health(options) {
+  async checkHealth(options) {
     const { data, error } = await this.#api.GET("/health", {
       params: { path: { version: "v1" } },
       body: options ?? {}
@@ -1067,7 +1061,7 @@ var StatusService = class {
 };
 
 // src/services/webhooks.ts
-var WebhooksService = class {
+var Webhooks = class {
   #api;
   constructor(api) {
     this.#api = api;
@@ -1075,14 +1069,15 @@ var WebhooksService = class {
   /**
    * List all webhooks in a workspace
    * @param workspaceId - Workspace ID
-   * @returns Promise that resolves with the list of webhooks
+   * @param query - Optional pagination parameters (limit, after)
+   * @returns Promise that resolves with a paginated list of webhooks
    * @throws {ApiError} if the request fails
    */
-  async list(workspaceId) {
+  async listWebhooks(workspaceId, query) {
     const { data } = await this.#api.GET(
-      "/workspaces/{workspace_id}/webhooks/",
+      "/workspaces/{workspaceId}/webhooks/",
       {
-        params: { path: { workspaceId } }
+        params: { path: { workspaceId }, query }
       }
     );
     return data;
@@ -1093,8 +1088,8 @@ var WebhooksService = class {
    * @returns Promise that resolves with the webhook details
    * @throws {ApiError} if the request fails
    */
-  async get(webhookId) {
-    const { data } = await this.#api.GET("/webhooks/{webhook_id}/", {
+  async getWebhook(webhookId) {
+    const { data } = await this.#api.GET("/webhooks/{webhookId}/", {
       params: { path: { webhookId } }
     });
     return data;
@@ -1103,12 +1098,12 @@ var WebhooksService = class {
    * Create a new webhook
    * @param workspaceId - Workspace ID
    * @param webhook - Webhook creation request
-   * @returns Promise that resolves with the created webhook (includes secret, shown only once)
+   * @returns Promise that resolves with the created webhook
    * @throws {ApiError} if the request fails
    */
-  async create(workspaceId, webhook) {
+  async createWebhook(workspaceId, webhook) {
     const { data } = await this.#api.POST(
-      "/workspaces/{workspace_id}/webhooks/",
+      "/workspaces/{workspaceId}/webhooks/",
       {
         params: { path: { workspaceId } },
         body: webhook
@@ -1123,8 +1118,8 @@ var WebhooksService = class {
    * @returns Promise that resolves with the updated webhook
    * @throws {ApiError} if the request fails
    */
-  async update(webhookId, updates) {
-    const { data } = await this.#api.PUT("/webhooks/{webhook_id}/", {
+  async updateWebhook(webhookId, updates) {
+    const { data } = await this.#api.PUT("/webhooks/{webhookId}/", {
       params: { path: { webhookId } },
       body: updates
     });
@@ -1136,26 +1131,40 @@ var WebhooksService = class {
    * @returns Promise that resolves when the webhook is deleted
    * @throws {ApiError} if the request fails
    */
-  async delete(webhookId) {
-    await this.#api.DELETE("/webhooks/{webhook_id}/", {
+  async deleteWebhook(webhookId) {
+    await this.#api.DELETE("/webhooks/{webhookId}/", {
       params: { path: { webhookId } }
     });
   }
+  /**
+   * Test a webhook by sending a test payload
+   * @param webhookId - Webhook ID
+   * @param options - Test webhook options
+   * @returns Promise that resolves with the test result
+   * @throws {ApiError} if the request fails
+   */
+  async testWebhook(webhookId, options) {
+    const { data } = await this.#api.POST("/webhooks/{webhookId}/test/", {
+      params: { path: { webhookId } },
+      body: options ?? {}
+    });
+    return data;
+  }
 };
 
 // src/services/workspaces.ts
-var WorkspacesService = class {
+var Workspaces = class {
   #api;
   constructor(api) {
     this.#api = api;
   }
   /**
    * List all workspaces
-   * @param query - Optional query parameters (offset, limit)
-   * @returns Promise that resolves with the list of workspaces
+   * @param query - Optional pagination parameters (limit, after)
+   * @returns Promise that resolves with a paginated list of workspaces
    * @throws {ApiError} if the request fails
    */
-  async list(query) {
+  async listWorkspaces(query) {
     const { data } = await this.#api.GET("/workspaces/", {
       params: { query }
     });
@@ -1167,8 +1176,8 @@ var WorkspacesService = class {
    * @returns Promise that resolves with the workspace details
    * @throws {ApiError} if the request fails
    */
-  async get(workspaceId) {
-    const { data } = await this.#api.GET("/workspaces/{workspace_id}/", {
+  async getWorkspace(workspaceId) {
+    const { data } = await this.#api.GET("/workspaces/{workspaceId}/", {
       params: { path: { workspaceId } }
     });
     return data;
@@ -1179,7 +1188,7 @@ var WorkspacesService = class {
    * @returns Promise that resolves with the created workspace
    * @throws {ApiError} if the request fails
    */
-  async create(workspace) {
+  async createWorkspace(workspace) {
     const { data } = await this.#api.POST("/workspaces/", {
       body: workspace
     });
@@ -1192,8 +1201,8 @@ var WorkspacesService = class {
    * @returns Promise that resolves with the updated workspace
    * @throws {ApiError} if the request fails
    */
-  async update(workspaceId, updates) {
-    const { data } = await this.#api.PATCH("/workspaces/{workspace_id}/", {
+  async updateWorkspace(workspaceId, updates) {
+    const { data } = await this.#api.PATCH("/workspaces/{workspaceId}/", {
       params: { path: { workspaceId } },
       body: updates
     });
@@ -1205,15 +1214,47 @@ var WorkspacesService = class {
    * @returns Promise that resolves when the workspace is deleted
    * @throws {ApiError} if the request fails
    */
-  async delete(workspaceId) {
-    await this.#api.DELETE("/workspaces/{workspace_id}/", {
+  async deleteWorkspace(workspaceId) {
+    await this.#api.DELETE("/workspaces/{workspaceId}/", {
       params: { path: { workspaceId } }
     });
   }
+  /**
+   * Get notification settings for the authenticated user in a workspace
+   * @param workspaceId - Workspace ID
+   * @returns Promise that resolves with the notification settings
+   * @throws {ApiError} if the request fails
+   */
+  async getNotificationSettings(workspaceId) {
+    const { data } = await this.#api.GET(
+      "/workspaces/{workspaceId}/notifications",
+      {
+        params: { path: { workspaceId } }
+      }
+    );
+    return data;
+  }
+  /**
+   * Update notification settings for the authenticated user in a workspace
+   * @param workspaceId - Workspace ID
+   * @param settings - Notification settings update request
+   * @returns Promise that resolves with the updated notification settings
+   * @throws {ApiError} if the request fails
+   */
+  async updateNotificationSettings(workspaceId, settings) {
+    const { data } = await this.#api.PATCH(
+      "/workspaces/{workspaceId}/notifications",
+      {
+        params: { path: { workspaceId } },
+        body: settings
+      }
+    );
+    return data;
+  }
 };
 
 // src/client.ts
-var Client = class _Client {
+var Nvisy = class _Nvisy {
   /**
    * The resolved client configuration with defaults applied.
    * @internal
@@ -1228,15 +1269,15 @@ var Client = class _Client {
    * Creates a new Nvisy client instance.
    *
    * @param config - Configuration options with required `apiToken`
-   * @throws {ConfigError} If the API token is invalid
+   * @throws {NvisyError} If the API token is invalid
    *
    * @example
    * ```typescript
-   * const client = new Client({
+   * const nvisy = new Nvisy({
    *   apiToken: "your-api-token",
    *   baseUrl: "https://custom.api.nvisy.com",
    * });
-   * const account = await client.account.get();
+   * const account = await nvisy.account.getAccount();
    * ```
    */
   constructor(config) {
@@ -1245,7 +1286,8 @@ var Client = class _Client {
       apiToken: validatedToken,
       baseUrl: config.baseUrl ?? DEFAULTS.BASE_URL,
       headers: config.headers ?? {},
-      userAgent: config.userAgent ?? DEFAULTS.USER_AGENT
+      userAgent: config.userAgent ?? DEFAULTS.USER_AGENT,
+      withLogging: config.withLogging ?? false
     };
     this.#api = this.#createApiClient();
   }
@@ -1266,6 +1308,9 @@ var Client = class _Client {
       baseUrl: this.#config.baseUrl,
       headers
     });
+    if (this.#config.withLogging) {
+      api.use(createLoggingMiddleware());
+    }
     api.use(errorMiddleware);
     return api;
   }
@@ -1274,22 +1319,19 @@ var Client = class _Client {
    *
    * @param apiToken - The API token to validate
    * @returns The trimmed API token if valid
-   * @throws {ConfigError} If the API token is invalid
+   * @throws {NvisyError} If the API token is invalid
    * @internal
    */
   #validateApiToken(apiToken) {
     if (typeof apiToken !== "string" || apiToken.trim().length === 0) {
-      throw ConfigError.invalidField("apiToken", "must be a non-empty string");
+      throw new NvisyError("API token must be a non-empty string");
     }
     const trimmedToken = apiToken.trim();
     if (trimmedToken.length < 10) {
-      throw ConfigError.invalidField(
-        "apiToken",
-        "must be at least 10 characters"
-      );
+      throw new NvisyError("API token must be at least 10 characters");
     }
-    if (!/^[a-zA-Z0-9_-]+$/.test(trimmedToken)) {
-      throw ConfigError.invalidField("apiToken", "contains invalid characters");
+    if (!/^[a-zA-Z0-9_.\-]+$/.test(trimmedToken)) {
+      throw new NvisyError("API token contains invalid characters");
     }
     return trimmedToken;
   }
@@ -1301,20 +1343,20 @@ var Client = class _Client {
    * is preserved in the new client.
    *
    * @param apiToken - The new API token
-   * @returns A new Client instance with the new token
-   * @throws {ConfigError} If the API token is invalid
+   * @returns A new Nvisy instance with the new token
+   * @throws {NvisyError} If the API token is invalid
    *
    * @example
    * ```typescript
-   * const client = new Client({ apiToken: "original-token" });
-   * const newClient = client.withApiToken("new-token");
+   * const nvisy = new Nvisy({ apiToken: "original-token" });
+   * const newNvisy = nvisy.withApiToken("new-token");
    *
-   * // newClient uses the new token
-   * // client still uses the original token
+   * // newNvisy uses the new token
+   * // nvisy still uses the original token
    * ```
    */
   withApiToken(apiToken) {
-    return new _Client({ ...this.#config, apiToken });
+    return new _Nvisy({ ...this.#config, apiToken });
   }
   /**
    * The base URL used for API requests.
@@ -1337,102 +1379,102 @@ var Client = class _Client {
   }
   /**
    * Service for authentication operations (login, signup, logout).
-   *
-   * @returns The AuthService instance
    */
   get auth() {
-    return new AuthService(this.#api);
+    return new Auth(this.#api);
   }
   /**
    * Service for API status and health checks.
-   *
-   * @returns The StatusService instance
    */
   get status() {
-    return new StatusService(this.#api);
+    return new Status(this.#api);
   }
   /**
    * Service for managing the authenticated user's account.
-   *
-   * @returns The AccountService instance
    */
   get account() {
-    return new AccountService(this.#api);
+    return new Account(this.#api);
+  }
+  /**
+   * Service for viewing workspace activities.
+   */
+  get activities() {
+    return new Activities(this.#api);
+  }
+  /**
+   * Service for managing file annotations.
+   */
+  get annotations() {
+    return new Annotations(this.#api);
   }
   /**
    * Service for managing API tokens.
-   *
-   * @returns The ApiTokensService instance
    */
   get apiTokens() {
-    return new ApiTokensService(this.#api);
+    return new ApiTokens(this.#api);
   }
   /**
    * Service for managing file comments.
-   *
-   * @returns The CommentsService instance
    */
   get comments() {
-    return new CommentsService(this.#api);
+    return new Comments(this.#api);
   }
   /**
    * Service for document operations.
-   *
-   * @returns The DocumentsService instance
    */
   get documents() {
-    return new DocumentsService(this.#api);
+    return new Documents(this.#api);
   }
   /**
    * Service for file operations (upload, download, delete).
-   *
-   * @returns The FilesService instance
    */
   get files() {
-    return new FilesService(this.#api);
+    return new Files(this.#api);
   }
   /**
    * Service for managing integrations.
-   *
-   * @returns The IntegrationsService instance
    */
   get integrations() {
-    return new IntegrationsService(this.#api);
+    return new Integrations(this.#api);
   }
   /**
    * Service for managing workspace invitations.
-   *
-   * @returns The InvitesService instance
    */
   get invites() {
-    return new InvitesService(this.#api);
+    return new Invites(this.#api);
   }
   /**
    * Service for managing workspace members.
-   *
-   * @returns The MembersService instance
    */
   get members() {
-    return new MembersService(this.#api);
+    return new Members(this.#api);
+  }
+  /**
+   * Service for managing notifications.
+   */
+  get notifications() {
+    return new Notifications(this.#api);
+  }
+  /**
+   * Service for managing processing runs.
+   */
+  get runs() {
+    return new Runs(this.#api);
   }
   /**
    * Service for managing webhooks.
-   *
-   * @returns The WebhooksService instance
    */
   get webhooks() {
-    return new WebhooksService(this.#api);
+    return new Webhooks(this.#api);
   }
   /**
    * Service for managing workspaces.
-   *
-   * @returns The WorkspacesService instance
    */
   get workspaces() {
-    return new WorkspacesService(this.#api);
+    return new Workspaces(this.#api);
   }
 };
 
-export { AccountService, ActivitiesService, AnnotationsService, ApiError, ApiTokensService, AuthService, Client, ClientError, CommentsService, ConfigError, DEFAULTS, DocumentsService, FilesService, IntegrationsService, InvitesService, MembersService, NetworkError, NotificationsService, RunsService, StatusService, VERSION, WebhooksService, WorkspacesService };
+export { DEFAULTS, Nvisy, NvisyApiError, NvisyError, VERSION };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map