@nvisy/sdk 0.1.0 → 0.3.0

package/dist/index.js

@@ -3,62 +3,29 @@ import createClient from 'openapi-fetch';
 // src/client.ts
 
 // src/config.ts
-var ENV_VARS = {
-  API_KEY: "NVISY_API_KEY",
-  BASE_URL: "NVISY_BASE_URL",
-  TIMEOUT: "NVISY_TIMEOUT",
-  MAX_RETRIES: "NVISY_MAX_RETRIES"
-};
+var VERSION = "0.3.0";
 var DEFAULTS = {
-  baseUrl: "https://api.nvisy.com",
-  timeout: 3e4,
-  maxRetries: 3,
-  headers: {}
+  /**
+   * Default base URL for the Nvisy API.
+   */
+  BASE_URL: "https://api.nvisy.com",
+  /**
+   * Default user agent string.
+   */
+  USER_AGENT: `@nvisy/sdk v.${VERSION}`
 };
-function loadConfigFromEnv() {
-  const config = {};
-  const apiKey = process.env[ENV_VARS.API_KEY];
-  if (apiKey) {
-    config.apiKey = apiKey;
-  }
-  const baseUrl = process.env[ENV_VARS.BASE_URL];
-  if (baseUrl) {
-    config.baseUrl = baseUrl;
-  }
-  const timeout = process.env[ENV_VARS.TIMEOUT];
-  if (timeout) {
-    const timeoutMs = parseInt(timeout, 10);
-    if (!Number.isNaN(timeoutMs)) {
-      config.timeout = timeoutMs;
-    }
-  }
-  const maxRetries = process.env[ENV_VARS.MAX_RETRIES];
-  if (maxRetries) {
-    const retries = parseInt(maxRetries, 10);
-    if (!Number.isNaN(retries)) {
-      config.maxRetries = retries;
-    }
-  }
-  return config;
-}
-function resolveConfig(userConfig) {
-  const envConfig = loadConfigFromEnv();
-  const mergedConfig = { ...envConfig, ...userConfig };
-  return {
-    apiKey: mergedConfig.apiKey || "",
-    baseUrl: mergedConfig.baseUrl || DEFAULTS.baseUrl,
-    timeout: mergedConfig.timeout ?? DEFAULTS.timeout,
-    maxRetries: mergedConfig.maxRetries ?? DEFAULTS.maxRetries,
-    headers: { ...DEFAULTS.headers, ...mergedConfig.headers }
-  };
-}
-function getEnvironmentVariables() {
-  return { ...ENV_VARS };
-}
 
 // src/errors.ts
-var ClientError = 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;
@@ -66,490 +33,1448 @@ var ClientError = class extends Error {
       Error.captureStackTrace(this, this.constructor);
     }
   }
+};
+var NvisyApiError = class extends NvisyError {
   /**
-   * Convert error to JSON representation
+   * The error type identifier (e.g., "ValidationError", "NotFoundError").
+   */
+  name;
+  /**
+   * Human-readable error message safe for display to end users.
+   */
+  message;
+  /**
+   * The resource type that the error relates to (e.g., "account", "project").
+   * May be null if the error is not resource-specific.
+   */
+  resource;
+  /**
+   * A helpful suggestion for resolving the error.
+   * May be null if no suggestion is available.
+   */
+  suggestion;
+  /**
+   * Field-specific validation errors.
+   * Present when the error is due to invalid input data.
+   */
+  validation;
+  /**
+   * HTTP status code of the response (e.g., 400, 404, 500).
+   */
+  statusCode;
+  /**
+   * 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
+   */
+  constructor(response, statusCode) {
+    super(response.message);
+    this.name = response.name;
+    this.message = response.message;
+    this.resource = response.resource;
+    this.suggestion = response.suggestion;
+    this.validation = response.validation;
+    this.statusCode = statusCode;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  /**
+   * Checks if this is a client error (4xx status code).
+   *
+   * Client errors indicate problems with the request itself, such as
+   * invalid input, missing authentication, or accessing non-existent resources.
+   *
+   * @returns True if the status code is in the 4xx range
+   */
+  isClientError() {
+    return this.statusCode >= 400 && this.statusCode < 500;
+  }
+  /**
+   * Checks if this is a server error (5xx status code).
+   *
+   * Server errors indicate problems on the API side. These are typically
+   * transient and may succeed if retried.
+   *
+   * @returns True if the status code is in the 5xx range
+   */
+  isServerError() {
+    return this.statusCode >= 500;
+  }
+  /**
+   * Determines if this error is safe to retry.
+   *
+   * An error is considered retryable if it's a server error (5xx),
+   * a request timeout (408), or rate limiting (429).
+   *
+   * @returns True if the request may succeed on retry
+   */
+  isRetryable() {
+    return this.statusCode >= 500 || // Server errors
+    this.statusCode === 408 || // Request timeout
+    this.statusCode === 429;
+  }
+  /**
+   * Converts the error to a plain {@link ErrorResponse} object.
+   *
+   * Useful for serialization or logging.
+   *
+   * @returns A plain object representation of the error
    */
   toJSON() {
     return {
       name: this.name,
       message: this.message,
-      context: ""
+      resource: this.resource,
+      suggestion: this.suggestion,
+      validation: this.validation
     };
   }
 };
-var ConfigError = class _ConfigError extends ClientError {
-  /** Field that caused the error (for validation errors) */
-  field;
-  /** Reason why the configuration is invalid */
-  reason;
-  constructor(message, options) {
-    super(message);
-    this.field = options?.field;
-    this.reason = options?.reason;
+
+// src/middleware/error.ts
+var errorMiddleware = {
+  async onResponse({ response }) {
+    if (!response.ok) {
+      const error = await response.clone().json();
+      throw new NvisyApiError(error, response.status);
+    }
+    return response;
+  },
+  onError({ error }) {
+    if (error instanceof Error) {
+      throw new NvisyError(error.message);
+    }
+    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 Account = class {
+  #api;
+  constructor(api) {
+    this.#api = api;
+  }
+  /**
+   * Get the authenticated user's account details
+   * @returns Promise that resolves with the account details
+   * @throws {ApiError} if the request fails
+   */
+  async getAccount() {
+    const { data } = await this.#api.GET("/account");
+    return data;
   }
   /**
-   * Create error for missing API key
+   * Update the authenticated user's account details
+   * @param updates - Account update request
+   * @returns Promise that resolves with the updated account
+   * @throws {ApiError} if the request fails
    */
-  static missingApiKey() {
-    return new _ConfigError("API key is required", {
-      field: "apiKey",
-      reason: "API key must be provided in configuration"
+  async updateAccount(updates) {
+    const { data } = await this.#api.PATCH("/account", {
+      body: updates
     });
+    return data;
   }
   /**
-   * Create error for invalid configuration field
+   * Delete the authenticated user's account
+   * @returns Promise that resolves when the account is deleted
+   * @throws {ApiError} if the request fails
    */
-  static invalidField(field, reason) {
-    return new _ConfigError(`Invalid configuration for ${field}: ${reason}`, {
-      field,
-      reason
+  async deleteAccount() {
+    await this.#api.DELETE("/account");
+  }
+};
+
+// src/services/activities.ts
+var Activities = class {
+  #api;
+  constructor(api) {
+    this.#api = api;
+  }
+  /**
+   * List activities for a workspace
+   * @param workspaceId - Workspace ID
+   * @param query - Optional pagination parameters (limit, after)
+   * @returns Promise that resolves with a paginated list of activities
+   * @throws {ApiError} if the request fails
+   */
+  async listActivities(workspaceId, query) {
+    const { data } = await this.#api.GET(
+      "/workspaces/{workspaceId}/activities/",
+      {
+        params: { path: { workspaceId }, query }
+      }
+    );
+    return data;
+  }
+};
+
+// src/services/annotations.ts
+var Annotations = class {
+  #api;
+  constructor(api) {
+    this.#api = api;
+  }
+  /**
+   * List annotations for a file
+   * @param fileId - File ID
+   * @param query - Optional pagination parameters (limit, after)
+   * @returns Promise that resolves with a paginated list of annotations
+   * @throws {ApiError} if the request fails
+   */
+  async listAnnotations(fileId, query) {
+    const { data } = await this.#api.GET("/files/{fileId}/annotations/", {
+      params: { path: { fileId }, query }
     });
+    return data;
   }
   /**
-   * Create error for missing required field
+   * Get annotation details by ID
+   * @param annotationId - Annotation ID
+   * @returns Promise that resolves with the annotation details
+   * @throws {ApiError} if the request fails
    */
-  static missingField(field) {
-    return new _ConfigError(`Missing required configuration field: ${field}`, {
-      field,
-      reason: "This field is required"
+  async getAnnotation(annotationId) {
+    const { data } = await this.#api.GET("/annotations/{annotationId}", {
+      params: { path: { annotationId } }
     });
+    return data;
   }
   /**
-   * Convert error to JSON representation
+   * Create a new annotation
+   * @param fileId - File ID
+   * @param annotation - Annotation creation request
+   * @returns Promise that resolves with the created annotation
+   * @throws {ApiError} if the request fails
    */
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      context: this.field || this.reason ? `field: ${this.field}, reason: ${this.reason}` : ""
-    };
+  async createAnnotation(fileId, annotation) {
+    const { data } = await this.#api.POST("/files/{fileId}/annotations/", {
+      params: { path: { fileId } },
+      body: annotation
+    });
+    return data;
+  }
+  /**
+   * Update an existing annotation
+   * @param annotationId - Annotation ID
+   * @param updates - Annotation update request
+   * @returns Promise that resolves with the updated annotation
+   * @throws {ApiError} if the request fails
+   */
+  async updateAnnotation(annotationId, updates) {
+    const { data } = await this.#api.PATCH("/annotations/{annotationId}", {
+      params: { path: { annotationId } },
+      body: updates
+    });
+    return data;
+  }
+  /**
+   * Delete an annotation
+   * @param annotationId - Annotation ID
+   * @returns Promise that resolves when the annotation is deleted
+   * @throws {ApiError} if the request fails
+   */
+  async deleteAnnotation(annotationId) {
+    await this.#api.DELETE("/annotations/{annotationId}", {
+      params: { path: { annotationId } }
+    });
   }
 };
-var NetworkError = class _NetworkError extends ClientError {
-  /** Original error that caused this network error */
-  cause;
-  constructor(message, cause) {
-    super(message);
-    this.cause = cause;
+
+// src/services/api-tokens.ts
+var ApiTokens = class {
+  #api;
+  constructor(api) {
+    this.#api = api;
   }
   /**
-   * Create error for network/connection issues
+   * List all API tokens for the authenticated account
+   * @param query - Optional pagination parameters (limit, after)
+   * @returns Promise that resolves with a paginated list of API tokens
+   * @throws {ApiError} if the request fails
    */
-  static connection(message, cause) {
-    return new _NetworkError(message, cause);
+  async listApiTokens(query) {
+    const { data } = await this.#api.GET("/api-tokens/", {
+      params: { query }
+    });
+    return data;
   }
   /**
-   * Create error for request timeout
+   * 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
    */
-  static timeout(timeoutMs) {
-    return new _NetworkError(`Request timed out after ${timeoutMs}ms`);
+  async getApiToken(tokenId) {
+    const { data } = await this.#api.GET("/api-tokens/{tokenId}/", {
+      params: { path: { tokenId } }
+    });
+    return data;
   }
   /**
-   * Create error for aborted request
+   * Create a new API token
+   * @param token - Token creation request
+   * @returns Promise that resolves with the created token (includes JWT, shown only once)
+   * @throws {ApiError} if the request fails
    */
-  static aborted() {
-    return new _NetworkError("Request was aborted");
+  async createApiToken(token) {
+    const { data } = await this.#api.POST("/api-tokens/", {
+      body: token
+    });
+    return data;
   }
   /**
-   * Create error for DNS resolution failure
+   * Update an existing API token
+   * @param tokenId - The token identifier
+   * @param updates - Token update request
+   * @returns Promise that resolves with the updated token
+   * @throws {ApiError} if the request fails
    */
-  static dnsResolution(hostname) {
-    return new _NetworkError(`Failed to resolve hostname: ${hostname}`);
+  async updateApiToken(tokenId, updates) {
+    const { data } = await this.#api.PATCH("/api-tokens/{tokenId}/", {
+      params: { path: { tokenId } },
+      body: updates
+    });
+    return data;
   }
   /**
-   * Convert error to JSON representation
+   * Revoke an API token
+   * @param tokenId - The token identifier
+   * @returns Promise that resolves when the token is revoked
+   * @throws {ApiError} if the request fails
    */
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      context: this.cause ? `cause: ${this.cause.message}` : ""
-    };
+  async revokeApiToken(tokenId) {
+    await this.#api.DELETE("/api-tokens/{tokenId}/", {
+      params: { path: { tokenId } }
+    });
   }
 };
-var ApiError = class _ApiError extends ClientError {
-  /** Error response from server */
-  errorResponse;
-  /** HTTP status code */
-  statusCode;
-  /** Request ID for debugging */
-  requestId;
-  constructor(message, statusCode, options) {
-    super(message);
-    this.statusCode = statusCode;
-    this.errorResponse = options?.errorResponse;
-    this.requestId = options?.requestId;
+
+// src/services/auth.ts
+var Auth = class {
+  #api;
+  constructor(api) {
+    this.#api = api;
   }
   /**
-   * Create error from HTTP response
+   * Login with email and password
+   * @param credentials - Login credentials
+   * @returns Promise that resolves with the auth response containing access token
+   * @throws {ApiError} if the request fails
    */
-  static fromResponse(response, errorData, requestId) {
-    const message = errorData?.message || `HTTP ${response.status}: ${response.statusText}`;
-    return new _ApiError(message, response.status, {
-      errorResponse: errorData,
-      requestId
+  async loginAccount(credentials) {
+    const { data } = await this.#api.POST("/auth/login", {
+      body: credentials
     });
+    return data;
   }
   /**
-   * Create error for rate limiting
+   * Sign up a new account
+   * @param credentials - Signup details
+   * @returns Promise that resolves with the auth response containing access token
+   * @throws {ApiError} if the request fails
    */
-  static rateLimited(retryAfter, requestId) {
-    const message = retryAfter ? `Rate limited. Retry after ${retryAfter} seconds` : "Rate limited";
-    return new _ApiError(message, 429, {
-      requestId,
-      errorResponse: {
-        name: "RateLimitError",
-        message,
-        context: retryAfter ? `retryAfter: ${retryAfter}` : ""
-      }
+  async signupAccount(credentials) {
+    const { data } = await this.#api.POST("/auth/signup", {
+      body: credentials
     });
+    return data;
   }
   /**
-   * Check if error is a client error (4xx)
+   * Logout and invalidate the current access token
+   * @returns Promise that resolves when logout is complete
+   * @throws {ApiError} if the request fails
    */
-  isClientError() {
-    return this.statusCode ? this.statusCode >= 400 && this.statusCode < 500 : false;
+  async logoutAccount() {
+    await this.#api.POST("/auth/logout");
+  }
+};
+
+// src/services/comments.ts
+var Comments = class {
+  #api;
+  constructor(api) {
+    this.#api = api;
   }
   /**
-   * Check if error is a server error (5xx)
+   * List all comments on a file
+   * @param fileId - File ID
+   * @param query - Optional pagination parameters (limit, after)
+   * @returns Promise that resolves with a paginated list of comments
+   * @throws {ApiError} if the request fails
    */
-  isServerError() {
-    return this.statusCode ? this.statusCode >= 500 : false;
+  async listComments(fileId, query) {
+    const { data } = await this.#api.GET("/files/{fileId}/comments", {
+      params: { path: { fileId }, query }
+    });
+    return data;
   }
   /**
-   * Check if error is retryable based on HTTP status
+   * Create a new comment on a file
+   * @param fileId - File ID
+   * @param comment - Comment creation request
+   * @returns Promise that resolves with the created comment
+   * @throws {ApiError} if the request fails
    */
-  isRetryable() {
-    if (!this.statusCode) return false;
-    return this.statusCode >= 500 || // Server errors
-    this.statusCode === 408 || // Request timeout
-    this.statusCode === 429;
+  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 commentId - Comment ID
+   * @returns Promise that resolves when the comment is deleted
+   * @throws {ApiError} if the request fails
+   */
+  async deleteComment(commentId) {
+    await this.#api.DELETE("/comments/{commentId}", {
+      params: { path: { commentId } }
+    });
+  }
+};
+
+// src/services/documents.ts
+var Documents = class {
+  #api;
+  constructor(api) {
+    this.#api = api;
   }
   /**
-   * Get retry delay in milliseconds (returns null if not retryable)
+   * List documents in a workspace
+   * @param workspaceId - Workspace ID
+   * @param query - Optional pagination parameters (limit, after)
+   * @returns Promise that resolves with a paginated list of documents
+   * @throws {ApiError} if the request fails
    */
-  getRetryDelay() {
-    if (!this.isRetryable()) return null;
-    if (this.statusCode === 429 && this.errorResponse?.context) {
-      const match = this.errorResponse.context.match(/retryAfter: (\d+)/);
-      if (match) {
-        const retryAfter = parseInt(match[1], 10);
-        return retryAfter * 1e3;
+  async listDocuments(workspaceId, query) {
+    const { data } = await this.#api.GET(
+      "/workspaces/{workspaceId}/documents",
+      {
+        params: { path: { workspaceId }, query }
       }
+    );
+    return data;
+  }
+  /**
+   * Get document details by ID
+   * @param documentId - Document ID
+   * @returns Promise that resolves with the document details
+   * @throws {ApiError} if the request fails
+   */
+  async getDocument(documentId) {
+    const { data } = await this.#api.GET("/documents/{documentId}", {
+      params: { path: { documentId } }
+    });
+    return data;
+  }
+  /**
+   * Create a new document
+   * @param workspaceId - Workspace ID
+   * @param document - Document creation request
+   * @returns Promise that resolves with the created document
+   * @throws {ApiError} if the request fails
+   */
+  async createDocument(workspaceId, document) {
+    const { data } = await this.#api.POST(
+      "/workspaces/{workspaceId}/documents",
+      {
+        params: { path: { workspaceId } },
+        body: document
+      }
+    );
+    return data;
+  }
+  /**
+   * Update an existing document
+   * @param documentId - Document ID
+   * @param updates - Document update request
+   * @returns Promise that resolves with the updated document
+   * @throws {ApiError} if the request fails
+   */
+  async updateDocument(documentId, updates) {
+    const { data } = await this.#api.PATCH("/documents/{documentId}", {
+      params: { path: { documentId } },
+      body: updates
+    });
+    return data;
+  }
+  /**
+   * Delete a document
+   * @param documentId - Document ID
+   * @returns Promise that resolves when the document is deleted
+   * @throws {ApiError} if the request fails
+   */
+  async deleteDocument(documentId) {
+    await this.#api.DELETE("/documents/{documentId}", {
+      params: { path: { documentId } }
+    });
+  }
+};
+
+// src/services/files.ts
+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);
     }
-    if (this.statusCode >= 500) {
-      return 1e3;
-    }
-    return 1e3;
+    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;
   }
   /**
-   * Convert error to JSON representation
+   * List files in a workspace
+   * @param workspaceId - Workspace ID
+   * @param query - Optional query parameters (formats, limit, after)
+   * @returns Promise that resolves with a paginated list of files
+   * @throws {ApiError} if the request fails
    */
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      context: `statusCode: ${this.statusCode}${this.requestId ? `, requestId: ${this.requestId}` : ""}${this.errorResponse ? `, errorResponse: ${JSON.stringify(this.errorResponse)}` : ""}`
-    };
+  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 downloadFile(fileId) {
+    const { response } = await this.#api.GET("/files/{fileId}/content", {
+      params: { path: { fileId } },
+      parseAs: "stream"
+    });
+    return response;
+  }
+  /**
+   * Update a file's metadata
+   * @param fileId - File ID
+   * @param updates - File update request
+   * @returns Promise that resolves with the updated file
+   * @throws {ApiError} if the request fails
+   */
+  async updateFile(fileId, updates) {
+    const { data } = await this.#api.PATCH("/files/{fileId}", {
+      params: { path: { fileId } },
+      body: updates
+    });
+    return data;
+  }
+  /**
+   * Delete a file
+   * @param fileId - File ID
+   * @returns Promise that resolves when the file is deleted
+   * @throws {ApiError} if the request fails
+   */
+  async deleteFile(fileId) {
+    await this.#api.DELETE("/files/{fileId}", {
+      params: { path: { fileId } }
+    });
+  }
+  /**
+   * Download files as an archive
+   * @param workspaceId - Workspace ID
+   * @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 downloadFiles(workspaceId, request) {
+    const { response } = await this.#api.GET(
+      "/workspaces/{workspaceId}/files/batch",
+      {
+        params: { path: { workspaceId } },
+        body: request,
+        parseAs: "stream"
+      }
+    );
+    return response;
+  }
+  /**
+   * Delete multiple files
+   * @param workspaceId - Workspace ID
+   * @param request - Delete request with file IDs
+   * @returns Promise that resolves when the files are deleted
+   * @throws {ApiError} if the request fails
+   */
+  async deleteFiles(workspaceId, request) {
+    await this.#api.DELETE("/workspaces/{workspaceId}/files/batch", {
+      params: { path: { workspaceId } },
+      body: request
+    });
   }
 };
 
-// src/client.ts
-var Client = class _Client {
-  #config;
-  #openApiClient;
+// src/services/integrations.ts
+var Integrations = class {
+  #api;
+  constructor(api) {
+    this.#api = api;
+  }
   /**
-   * Create a new Nvisy client instance
+   * List integrations for a workspace
+   * @param workspaceId - Workspace ID
+   * @param query - Optional pagination parameters (limit, after)
+   * @returns Promise that resolves with a paginated list of integrations
+   * @throws {ApiError} if the request fails
    */
-  constructor(userConfig) {
-    try {
-      this.#validateConfig(userConfig);
-      this.#config = resolveConfig(userConfig);
-    } catch (error) {
-      if (error instanceof ConfigError) {
-        throw error;
+  async listIntegrations(workspaceId, query) {
+    const { data } = await this.#api.GET(
+      "/workspaces/{workspaceId}/integrations/",
+      {
+        params: { path: { workspaceId }, query }
       }
-      throw ConfigError.invalidField(
-        "config",
-        `Configuration error: ${String(error)}`
-      );
-    }
-    this.#openApiClient = createClient({
-      baseUrl: this.#config.baseUrl,
-      headers: {
-        Authorization: `Bearer ${this.#config.apiKey}`,
-        "Content-Type": "application/json",
-        "User-Agent": this.#buildUserAgent(),
-        ...this.#config.headers
+    );
+    return data;
+  }
+  /**
+   * Get integration details by ID
+   * @param integrationId - Integration ID
+   * @returns Promise that resolves with the integration details
+   * @throws {ApiError} if the request fails
+   */
+  async getIntegration(integrationId) {
+    const { data } = await this.#api.GET("/integrations/{integrationId}/", {
+      params: { path: { integrationId } }
+    });
+    return data;
+  }
+  /**
+   * Create a new integration
+   * @param workspaceId - Workspace ID
+   * @param integration - Integration creation request
+   * @returns Promise that resolves with the created integration
+   * @throws {ApiError} if the request fails
+   */
+  async createIntegration(workspaceId, integration) {
+    const { data } = await this.#api.POST(
+      "/workspaces/{workspaceId}/integrations/",
+      {
+        params: { path: { workspaceId } },
+        body: integration
       }
+    );
+    return data;
+  }
+  /**
+   * Update an existing integration
+   * @param integrationId - Integration ID
+   * @param updates - Integration update request
+   * @returns Promise that resolves with the updated integration
+   * @throws {ApiError} if the request fails
+   */
+  async updateIntegration(integrationId, updates) {
+    const { data } = await this.#api.PUT("/integrations/{integrationId}/", {
+      params: { path: { integrationId } },
+      body: updates
     });
+    return data;
   }
   /**
-   * Create a new ClientBuilder for fluent configuration
+   * Update integration credentials
+   * @param integrationId - Integration ID
+   * @param credentials - New credentials
+   * @returns Promise that resolves with the updated integration
+   * @throws {ApiError} if the request fails
    */
-  static builder() {
-    return new ClientBuilder();
+  async updateIntegrationCredentials(integrationId, credentials) {
+    const { data } = await this.#api.PATCH(
+      "/integrations/{integrationId}/credentials/",
+      {
+        params: { path: { integrationId } },
+        body: credentials
+      }
+    );
+    return data;
   }
   /**
-   * Create a client from environment variables
+   * Delete an integration
+   * @param integrationId - Integration ID
+   * @returns Promise that resolves when the integration is deleted
+   * @throws {ApiError} if the request fails
    */
-  static fromEnvironment() {
-    return ClientBuilder.fromEnvironment().build();
+  async deleteIntegration(integrationId) {
+    await this.#api.DELETE("/integrations/{integrationId}/", {
+      params: { path: { integrationId } }
+    });
+  }
+};
+
+// src/services/invites.ts
+var Invites = class {
+  #api;
+  constructor(api) {
+    this.#api = api;
   }
   /**
-   * Get the current configuration (readonly copy)
+   * List all invitations for a workspace
+   * @param workspaceId - Workspace ID
+   * @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
    */
-  getConfig() {
-    return Object.freeze({ ...this.#config });
+  async listInvites(workspaceId, query) {
+    const { data } = await this.#api.GET("/workspaces/{workspaceId}/invites/", {
+      params: { path: { workspaceId }, query }
+    });
+    return data;
   }
   /**
-   * Get the underlying openapi-fetch client for advanced usage
+   * Send an invitation to join a workspace
+   * @param workspaceId - Workspace ID
+   * @param invite - Invitation request
+   * @returns Promise that resolves with the created invitation
+   * @throws {ApiError} if the request fails
    */
-  getOpenApiClient() {
-    return this.#openApiClient;
+  async sendInvite(workspaceId, invite) {
+    const { data } = await this.#api.POST(
+      "/workspaces/{workspaceId}/invites/",
+      {
+        params: { path: { workspaceId } },
+        body: invite
+      }
+    );
+    return data;
   }
   /**
-   * Validate configuration by reusing ClientBuilder validation
+   * Cancel a pending invitation
+   * @param inviteId - Invite ID
+   * @returns Promise that resolves when the invitation is canceled
+   * @throws {ApiError} if the request fails
    */
-  #validateConfig(config) {
-    const builder = new ClientBuilder().withApiKey(config.apiKey);
-    if (config.baseUrl !== void 0) {
-      builder.withBaseUrl(config.baseUrl);
-    }
-    if (config.timeout !== void 0) {
-      builder.withTimeout(config.timeout);
-    }
-    if (config.maxRetries !== void 0) {
-      builder.withMaxRetries(config.maxRetries);
-    }
-    if (config.headers !== void 0) {
-      builder.withHeaders(config.headers);
-    }
+  async cancelInvite(inviteId) {
+    await this.#api.DELETE("/invites/{inviteId}/", {
+      params: { path: { inviteId } }
+    });
   }
   /**
-   * Build user agent string
+   * Reply to an invitation (accept or decline)
+   * @param inviteId - Invite ID
+   * @param reply - Reply request
+   * @returns Promise that resolves with the updated invitation
+   * @throws {ApiError} if the request fails
    */
-  #buildUserAgent() {
-    const sdkVersion = "1.0.0";
-    const nodeVersion = process.version;
-    const platform = process.platform;
-    return `@nvisy/sdk/${sdkVersion} (${platform}; Node.js ${nodeVersion})`;
+  async replyToInvite(inviteId, reply) {
+    const { data } = await this.#api.POST("/invites/{inviteId}/", {
+      params: { path: { inviteId } },
+      body: reply
+    });
+    return data;
   }
   /**
-   * Create a new client with modified configuration
+   * Generate a shareable invite code for a workspace
+   * @param workspaceId - Workspace ID
+   * @param options - Invite code generation options
+   * @returns Promise that resolves with the generated invite code
+   * @throws {ApiError} if the request fails
    */
-  withConfig(configChanges) {
-    const newConfig = {
-      apiKey: this.#config.apiKey,
-      baseUrl: this.#config.baseUrl,
-      timeout: this.#config.timeout,
-      maxRetries: this.#config.maxRetries,
-      headers: this.#config.headers,
-      ...configChanges
-    };
-    return new _Client(newConfig);
+  async generateInviteCode(workspaceId, options) {
+    const { data } = await this.#api.POST(
+      "/workspaces/{workspaceId}/invites/code/",
+      {
+        params: { path: { workspaceId } },
+        body: options
+      }
+    );
+    return data;
+  }
+  /**
+   * Reply to an invite code (accept or decline)
+   * @param inviteCode - The invite code
+   * @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 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;
+  }
+};
+
+// src/services/members.ts
+var Members = class {
+  #api;
+  constructor(api) {
+    this.#api = api;
   }
   /**
-   * Create a new client with additional headers
+   * List members of a workspace
+   * @param workspaceId - Workspace ID
+   * @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
    */
-  withHeaders(additionalHeaders) {
-    return this.withConfig({
-      headers: { ...this.#config.headers, ...additionalHeaders }
+  async listMembers(workspaceId, query) {
+    const { data } = await this.#api.GET("/workspaces/{workspaceId}/members/", {
+      params: { path: { workspaceId }, query }
     });
+    return data;
+  }
+  /**
+   * Get member details by account ID
+   * @param workspaceId - Workspace ID
+   * @param accountId - Account ID
+   * @returns Promise that resolves with the member details
+   * @throws {ApiError} if the request fails
+   */
+  async getMember(workspaceId, accountId) {
+    const { data } = await this.#api.GET(
+      "/workspaces/{workspaceId}/members/{accountId}/",
+      {
+        params: {
+          path: { workspaceId, accountId }
+        }
+      }
+    );
+    return data;
   }
   /**
-   * Create a new client with a different timeout
+   * Update a member's role
+   * @param workspaceId - Workspace ID
+   * @param accountId - Account ID
+   * @param updates - New role for the member
+   * @returns Promise that resolves with the updated member
+   * @throws {ApiError} if the request fails
    */
-  withTimeout(timeoutMs) {
-    return this.withConfig({ timeout: timeoutMs });
+  async updateMember(workspaceId, accountId, updates) {
+    const { data } = await this.#api.PATCH(
+      "/workspaces/{workspaceId}/members/{accountId}/role",
+      {
+        params: {
+          path: { workspaceId, accountId }
+        },
+        body: updates
+      }
+    );
+    return data;
   }
   /**
-   * Create a new client with different retry settings
+   * Remove a member from a workspace
+   * @param workspaceId - Workspace ID
+   * @param accountId - Account ID
+   * @returns Promise that resolves when the member is removed
+   * @throws {ApiError} if the request fails
    */
-  withMaxRetries(maxRetries) {
-    return this.withConfig({ maxRetries });
+  async removeMember(workspaceId, accountId) {
+    await this.#api.DELETE("/workspaces/{workspaceId}/members/{accountId}/", {
+      params: { path: { workspaceId, accountId } }
+    });
+  }
+  /**
+   * Leave a workspace
+   * @param workspaceId - Workspace ID
+   * @returns Promise that resolves when the member has left
+   * @throws {ApiError} if the request fails
+   */
+  async leaveWorkspace(workspaceId) {
+    await this.#api.POST("/workspaces/{workspaceId}/members/leave", {
+      params: { path: { workspaceId } }
+    });
   }
 };
 
-// src/builder.ts
-var RESERVED_HEADERS = ["authorization", "content-type", "user-agent"];
-var ClientBuilder = class _ClientBuilder {
-  #config = {};
+// src/services/notifications.ts
+var Notifications = class {
+  #api;
+  constructor(api) {
+    this.#api = api;
+  }
   /**
-   * Create a ClientBuilder instance with an API key
+   * List notifications for the authenticated account
+   * @param query - Optional pagination parameters (limit, after)
+   * @returns Promise that resolves with a paginated list of notifications
+   * @throws {ApiError} if the request fails
    */
-  static fromApiKey(apiKey) {
-    return new _ClientBuilder().withApiKey(apiKey);
+  async listNotifications(query) {
+    const { data } = await this.#api.GET("/notifications/", {
+      params: { query }
+    });
+    return data;
   }
   /**
-   * Create a ClientBuilder instance from environment variables
+   * Get the unread notifications count for the authenticated account
+   * @returns Promise that resolves with the unread status
+   * @throws {ApiError} if the request fails
    */
-  static fromEnvironment() {
-    const envConfig = loadConfigFromEnv();
-    if (!envConfig.apiKey) {
-      throw ConfigError.missingApiKey();
-    }
-    const builder = new _ClientBuilder().withApiKey(envConfig.apiKey);
-    if (envConfig.baseUrl) {
-      builder.withBaseUrl(envConfig.baseUrl);
-    }
-    if (envConfig.timeout) {
-      builder.withTimeout(envConfig.timeout);
-    }
-    if (envConfig.maxRetries !== void 0) {
-      builder.withMaxRetries(envConfig.maxRetries);
-    }
-    if (envConfig.headers) {
-      builder.withHeaders(envConfig.headers);
-    }
-    return builder;
+  async getUnreadNotificationsStatus() {
+    const { data } = await this.#api.GET("/notifications/unread");
+    return data;
+  }
+};
+
+// src/services/runs.ts
+var Runs = class {
+  #api;
+  constructor(api) {
+    this.#api = api;
   }
   /**
-   * Set the API key for authentication
+   * List integration runs for a workspace
+   * @param workspaceId - Workspace ID
+   * @param query - Optional pagination parameters (limit, after)
+   * @returns Promise that resolves with a paginated list of integration runs
+   * @throws {ApiError} if the request fails
    */
-  withApiKey(apiKey) {
-    this.#validateString("apiKey", apiKey);
-    const trimmedKey = apiKey.trim();
-    if (trimmedKey.length < 10) {
-      throw ConfigError.invalidField(
-        "apiKey",
-        "must be at least 10 characters"
-      );
-    }
-    if (!/^[a-zA-Z0-9_-]+$/.test(trimmedKey)) {
-      throw ConfigError.invalidField("apiKey", "contains invalid characters");
-    }
-    this.#config.apiKey = trimmedKey;
-    return this;
+  async listRuns(workspaceId, query) {
+    const { data } = await this.#api.GET("/workspaces/{workspaceId}/runs/", {
+      params: { path: { workspaceId }, query }
+    });
+    return data;
   }
   /**
-   * Set the base URL for the API
+   * Get integration run details by ID
+   * @param runId - Run ID
+   * @returns Promise that resolves with the integration run details
+   * @throws {ApiError} if the request fails
    */
-  withBaseUrl(baseUrl) {
-    this.#validateString("baseUrl", baseUrl);
-    this.#validateUrl(baseUrl);
-    this.#config.baseUrl = baseUrl;
-    return this;
+  async getRun(runId) {
+    const { data } = await this.#api.GET("/runs/{runId}", {
+      params: { path: { runId } }
+    });
+    return data;
+  }
+};
+
+// src/services/status.ts
+var Status = class {
+  #api;
+  constructor(api) {
+    this.#api = api;
   }
   /**
-   * Set the request timeout in milliseconds
+   * Check the health status of the API
+   * @param options - Health check options
+   * @returns Promise that resolves with the API health status
    */
-  withTimeout(timeoutMs) {
-    this.#validateInteger("timeout", timeoutMs, 1e3, 3e5);
-    this.#config.timeout = timeoutMs;
-    return this;
+  async checkHealth(options) {
+    const { data, error } = await this.#api.GET("/health", {
+      params: { path: { version: "v1" } },
+      body: options ?? {}
+    });
+    return data ?? error;
+  }
+};
+
+// src/services/webhooks.ts
+var Webhooks = class {
+  #api;
+  constructor(api) {
+    this.#api = api;
   }
   /**
-   * Set the maximum number of retry attempts
+   * List all webhooks in a workspace
+   * @param workspaceId - Workspace ID
+   * @param query - Optional pagination parameters (limit, after)
+   * @returns Promise that resolves with a paginated list of webhooks
+   * @throws {ApiError} if the request fails
    */
-  withMaxRetries(maxRetries) {
-    this.#validateInteger("maxRetries", maxRetries, 0, 5);
-    this.#config.maxRetries = maxRetries;
-    return this;
+  async listWebhooks(workspaceId, query) {
+    const { data } = await this.#api.GET(
+      "/workspaces/{workspaceId}/webhooks/",
+      {
+        params: { path: { workspaceId }, query }
+      }
+    );
+    return data;
   }
   /**
-   * Add a single custom header (merges with existing headers)
+   * Get a specific webhook by ID
+   * @param webhookId - Webhook ID
+   * @returns Promise that resolves with the webhook details
+   * @throws {ApiError} if the request fails
    */
-  withHeader(name, value) {
-    this.#validateSingleHeader(name, value);
-    if (!this.#config.headers) {
-      this.#config.headers = {};
-    }
-    this.#config.headers[name] = value;
-    return this;
+  async getWebhook(webhookId) {
+    const { data } = await this.#api.GET("/webhooks/{webhookId}/", {
+      params: { path: { webhookId } }
+    });
+    return data;
   }
   /**
-   * Set custom headers (merges with existing headers)
+   * Create a new webhook
+   * @param workspaceId - Workspace ID
+   * @param webhook - Webhook creation request
+   * @returns Promise that resolves with the created webhook
+   * @throws {ApiError} if the request fails
    */
-  withHeaders(headers) {
-    if (!headers || typeof headers !== "object" || Array.isArray(headers)) {
-      throw ConfigError.invalidField("headers", "must be a valid object");
-    }
-    for (const [name, value] of Object.entries(headers)) {
-      this.withHeader(name, value);
-    }
-    return this;
+  async createWebhook(workspaceId, webhook) {
+    const { data } = await this.#api.POST(
+      "/workspaces/{workspaceId}/webhooks/",
+      {
+        params: { path: { workspaceId } },
+        body: webhook
+      }
+    );
+    return data;
   }
   /**
-   * Build and return the configured client instance
+   * Update an existing webhook
+   * @param webhookId - Webhook ID
+   * @param updates - Webhook update request
+   * @returns Promise that resolves with the updated webhook
+   * @throws {ApiError} if the request fails
    */
-  build() {
-    if (!this.#config.apiKey) {
-      throw ConfigError.missingApiKey();
-    }
-    return new Client(this.#config);
+  async updateWebhook(webhookId, updates) {
+    const { data } = await this.#api.PUT("/webhooks/{webhookId}/", {
+      params: { path: { webhookId } },
+      body: updates
+    });
+    return data;
   }
   /**
-   * Get the current configuration (for debugging/testing)
+   * Delete a webhook
+   * @param webhookId - Webhook ID
+   * @returns Promise that resolves when the webhook is deleted
+   * @throws {ApiError} if the request fails
    */
-  getConfig() {
-    return { ...this.#config };
+  async deleteWebhook(webhookId) {
+    await this.#api.DELETE("/webhooks/{webhookId}/", {
+      params: { path: { webhookId } }
+    });
   }
   /**
-   * Validate string field
+   * 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
    */
-  #validateString(fieldName, value) {
-    if (!value || typeof value !== "string" || value.trim().length === 0) {
-      throw ConfigError.invalidField(fieldName, "must be a non-empty string");
-    }
+  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 Workspaces = class {
+  #api;
+  constructor(api) {
+    this.#api = api;
   }
   /**
-   * Validate integer field with range
+   * List all workspaces
+   * @param query - Optional pagination parameters (limit, after)
+   * @returns Promise that resolves with a paginated list of workspaces
+   * @throws {ApiError} if the request fails
    */
-  #validateInteger(fieldName, value, min, max) {
-    if (!Number.isInteger(value) || value < min) {
-      throw ConfigError.invalidField(fieldName, `must be an integer >= ${min}`);
-    }
-    if (value > max) {
-      throw ConfigError.invalidField(fieldName, `must not exceed ${max}`);
-    }
+  async listWorkspaces(query) {
+    const { data } = await this.#api.GET("/workspaces/", {
+      params: { query }
+    });
+    return data;
   }
   /**
-   * Validate URL format
+   * Get workspace details by ID
+   * @param workspaceId - Workspace ID
+   * @returns Promise that resolves with the workspace details
+   * @throws {ApiError} if the request fails
    */
-  #validateUrl(baseUrl) {
-    let url;
-    try {
-      url = new URL(baseUrl);
-    } catch {
-      throw ConfigError.invalidField("baseUrl", "must be a valid URL");
-    }
-    const allowedProtocols = ["https:", "http:"];
-    if (!allowedProtocols.includes(url.protocol)) {
-      throw ConfigError.invalidField(
-        "baseUrl",
-        `protocol must be one of: ${allowedProtocols.join(", ")}`
-      );
-    }
+  async getWorkspace(workspaceId) {
+    const { data } = await this.#api.GET("/workspaces/{workspaceId}/", {
+      params: { path: { workspaceId } }
+    });
+    return data;
   }
   /**
-   * Validate single header name and value
+   * Create a new workspace
+   * @param workspace - Workspace creation request
+   * @returns Promise that resolves with the created workspace
+   * @throws {ApiError} if the request fails
    */
-  #validateSingleHeader(name, value) {
-    if (!name || typeof name !== "string" || name.trim().length === 0) {
-      throw ConfigError.invalidField(
-        "header name",
-        "must be a non-empty string"
-      );
+  async createWorkspace(workspace) {
+    const { data } = await this.#api.POST("/workspaces/", {
+      body: workspace
+    });
+    return data;
+  }
+  /**
+   * Update an existing workspace
+   * @param workspaceId - Workspace ID
+   * @param updates - Workspace update request
+   * @returns Promise that resolves with the updated workspace
+   * @throws {ApiError} if the request fails
+   */
+  async updateWorkspace(workspaceId, updates) {
+    const { data } = await this.#api.PATCH("/workspaces/{workspaceId}/", {
+      params: { path: { workspaceId } },
+      body: updates
+    });
+    return data;
+  }
+  /**
+   * Delete a workspace
+   * @param workspaceId - Workspace ID
+   * @returns Promise that resolves when the workspace is deleted
+   * @throws {ApiError} if the request fails
+   */
+  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 Nvisy = class _Nvisy {
+  /**
+   * The resolved client configuration with defaults applied.
+   * @internal
+   */
+  #config;
+  /**
+   * The underlying openapi-fetch client instance.
+   * @internal
+   */
+  #api;
+  /**
+   * Creates a new Nvisy client instance.
+   *
+   * @param config - Configuration options with required `apiToken`
+   * @throws {NvisyError} If the API token is invalid
+   *
+   * @example
+   * ```typescript
+   * const nvisy = new Nvisy({
+   *   apiToken: "your-api-token",
+   *   baseUrl: "https://custom.api.nvisy.com",
+   * });
+   * const account = await nvisy.account.getAccount();
+   * ```
+   */
+  constructor(config) {
+    const validatedToken = this.#validateApiToken(config.apiToken);
+    this.#config = {
+      apiToken: validatedToken,
+      baseUrl: config.baseUrl ?? DEFAULTS.BASE_URL,
+      headers: config.headers ?? {},
+      userAgent: config.userAgent ?? DEFAULTS.USER_AGENT,
+      withLogging: config.withLogging ?? false
+    };
+    this.#api = this.#createApiClient();
+  }
+  /**
+   * Creates and configures the underlying openapi-fetch client.
+   *
+   * @returns A configured ApiClient instance
+   * @internal
+   */
+  #createApiClient() {
+    const headers = {
+      "Content-Type": "application/json",
+      "User-Agent": this.#config.userAgent,
+      Authorization: `Bearer ${this.#config.apiToken}`,
+      ...this.#config.headers
+    };
+    const api = createClient({
+      baseUrl: this.#config.baseUrl,
+      headers
+    });
+    if (this.#config.withLogging) {
+      api.use(createLoggingMiddleware());
     }
-    if (typeof value !== "string") {
-      throw ConfigError.invalidField("header value", "must be a string");
+    api.use(errorMiddleware);
+    return api;
+  }
+  /**
+   * Validates an API token format.
+   *
+   * @param apiToken - The API token to validate
+   * @returns The trimmed API token if valid
+   * @throws {NvisyError} If the API token is invalid
+   * @internal
+   */
+  #validateApiToken(apiToken) {
+    if (typeof apiToken !== "string" || apiToken.trim().length === 0) {
+      throw new NvisyError("API token must be a non-empty string");
     }
-    if (!/^[a-zA-Z0-9!#$%&'*+\-.^_`|~]+$/.test(name)) {
-      throw ConfigError.invalidField(
-        "header name",
-        `invalid header name: ${name}`
-      );
+    const trimmedToken = apiToken.trim();
+    if (trimmedToken.length < 10) {
+      throw new NvisyError("API token must be at least 10 characters");
     }
-    if (RESERVED_HEADERS.includes(name.toLowerCase())) {
-      throw ConfigError.invalidField(
-        "header name",
-        `header "${name}" is reserved and cannot be overridden`
-      );
+    if (!/^[a-zA-Z0-9_.\-]+$/.test(trimmedToken)) {
+      throw new NvisyError("API token contains invalid characters");
     }
+    return trimmedToken;
+  }
+  /**
+   * Creates a new client with a different API token.
+   *
+   * Returns a new client instance with the new token. The original client
+   * remains unchanged. All other configuration (base URL, headers, etc.)
+   * is preserved in the new client.
+   *
+   * @param apiToken - The new API token
+   * @returns A new Nvisy instance with the new token
+   * @throws {NvisyError} If the API token is invalid
+   *
+   * @example
+   * ```typescript
+   * const nvisy = new Nvisy({ apiToken: "original-token" });
+   * const newNvisy = nvisy.withApiToken("new-token");
+   *
+   * // newNvisy uses the new token
+   * // nvisy still uses the original token
+   * ```
+   */
+  withApiToken(apiToken) {
+    return new _Nvisy({ ...this.#config, apiToken });
+  }
+  /**
+   * The base URL used for API requests.
+   *
+   * @returns The configured base URL
+   */
+  get baseUrl() {
+    return this.#config.baseUrl;
+  }
+  /**
+   * The underlying openapi-fetch client for direct API access.
+   *
+   * Use this for advanced scenarios where you need direct access to the
+   * HTTP client, such as calling endpoints not covered by the service classes.
+   *
+   * @returns The configured ApiClient instance
+   */
+  get api() {
+    return this.#api;
+  }
+  /**
+   * Service for authentication operations (login, signup, logout).
+   */
+  get auth() {
+    return new Auth(this.#api);
+  }
+  /**
+   * Service for API status and health checks.
+   */
+  get status() {
+    return new Status(this.#api);
+  }
+  /**
+   * Service for managing the authenticated user's account.
+   */
+  get account() {
+    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.
+   */
+  get apiTokens() {
+    return new ApiTokens(this.#api);
+  }
+  /**
+   * Service for managing file comments.
+   */
+  get comments() {
+    return new Comments(this.#api);
+  }
+  /**
+   * Service for document operations.
+   */
+  get documents() {
+    return new Documents(this.#api);
+  }
+  /**
+   * Service for file operations (upload, download, delete).
+   */
+  get files() {
+    return new Files(this.#api);
+  }
+  /**
+   * Service for managing integrations.
+   */
+  get integrations() {
+    return new Integrations(this.#api);
+  }
+  /**
+   * Service for managing workspace invitations.
+   */
+  get invites() {
+    return new Invites(this.#api);
+  }
+  /**
+   * Service for managing workspace members.
+   */
+  get members() {
+    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.
+   */
+  get webhooks() {
+    return new Webhooks(this.#api);
+  }
+  /**
+   * Service for managing workspaces.
+   */
+  get workspaces() {
+    return new Workspaces(this.#api);
   }
 };
 
-export { ApiError, Client, ClientBuilder, ClientError, ConfigError, NetworkError, getEnvironmentVariables, loadConfigFromEnv, resolveConfig };
+export { DEFAULTS, Nvisy, NvisyApiError, NvisyError, VERSION };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map