@nvisy/sdk 0.2.0 → 0.4.0

package/dist/index.js

@@ -1,1438 +1,287 @@
-import createClient from 'openapi-fetch';
+import { a as VERSION, i as DEFAULTS, n as NvisyApiError, r as NvisyError, t as errorMiddleware } from "./error-DmkKaDjI.js";
+import { a as Policies, c as Members, d as Contexts, f as Connections, g as Account, h as Activities, i as Runs, l as Invites, m as ApiTokens, n as Webhooks, o as Pipelines, p as Auth, r as Status, s as Notifications, t as Workspaces, u as Files } from "./services-Dh0FMDzU.js";
+import createClient from "openapi-fetch";
 
-// src/client.ts
+//#region src/middleware/logging.ts
+/**
+* Creates a logging middleware for debugging requests and responses.
+*
+* Logs request method, URL, response status, and timing to console.
+*/
+function createLoggingMiddleware() {
+	return {
+		async onRequest({ request }) {
+			request._startTime = performance.now();
+			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/config.ts
-var VERSION = "0.2.0";
-var DEFAULTS = {
-  /**
-   * Default base URL for the Nvisy API.
-   */
-  BASE_URL: "https://api.nvisy.com",
-  /**
-   * Default user agent string.
-   */
-  USER_AGENT: `@nvisy/sdk v.${VERSION}`
+//#endregion
+//#region src/client.ts
+/**
+* @fileoverview Main client for the Nvisy SDK.
+*
+* This module exports the {@link Nvisy} class, which is the primary entry point
+* for interacting with the Nvisy document processing API.
+*
+* @module client
+*
+* @example
+* ```typescript
+* const nvisy = new Nvisy({ apiToken: "your-api-token" });
+* const account = await nvisy.account.getAccount();
+* ```
+*/
+/**
+* Main client class for interacting with the Nvisy document processing API.
+*
+* @example
+* ```typescript
+* const nvisy = new Nvisy({ apiToken: "your-api-token" });
+* const account = await nvisy.account.getAccount();
+* const workspaces = await nvisy.workspaces.listWorkspaces();
+* ```
+*/
+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());
+		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");
+		const trimmedToken = apiToken.trim();
+		if (trimmedToken.length < 10) throw new NvisyError("API token must be at least 10 characters");
+		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 API tokens.
+	*/
+	get apiTokens() {
+		return new ApiTokens(this.#api);
+	}
+	/**
+	* Service for managing connections.
+	*/
+	get connections() {
+		return new Connections(this.#api);
+	}
+	/**
+	* Service for managing contexts.
+	*/
+	get contexts() {
+		return new Contexts(this.#api);
+	}
+	/**
+	* Service for file operations (upload, download, delete).
+	*/
+	get files() {
+		return new Files(this.#api);
+	}
+	/**
+	* Service for managing pipelines.
+	*/
+	get pipelines() {
+		return new Pipelines(this.#api);
+	}
+	/**
+	* Service for managing policies.
+	*/
+	get policies() {
+		return new Policies(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 pipeline 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);
+	}
 };
 
-// src/errors.ts
-var ApiError = class extends Error {
-  /**
-   * 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.
-   */
-  validationErrors;
-  /**
-   * HTTP status code of the response (e.g., 400, 404, 500).
-   */
-  statusCode;
-  /**
-   * Creates a new ApiError 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.validationErrors = response.validationErrors;
-    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,
-      resource: this.resource,
-      suggestion: this.suggestion,
-      validationErrors: this.validationErrors
-    };
-  }
-};
-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);
-    }
-    return response;
-  },
-  onError({ error }) {
-    if (error instanceof Error) {
-      if (error.name === "AbortError") {
-        throw NetworkError.aborted();
-      }
-      throw NetworkError.connection(error.message, error);
-    }
-    throw NetworkError.connection("An unknown network error occurred");
-  }
-};
-
-// src/services/account.ts
-var AccountService = 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 get() {
-    const { data } = await this.#api.GET("/account");
-    return data;
-  }
-  /**
-   * 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
-   */
-  async update(updates) {
-    const { data } = await this.#api.PATCH("/account", {
-      body: updates
-    });
-    return data;
-  }
-  /**
-   * Delete the authenticated user's account
-   * @returns Promise that resolves when the account is deleted
-   * @throws {ApiError} if the request fails
-   */
-  async delete() {
-    await this.#api.DELETE("/account");
-  }
-};
-
-// src/services/activities.ts
-var ActivitiesService = class {
-  #api;
-  constructor(api) {
-    this.#api = api;
-  }
-  /**
-   * 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
-   * @throws {ApiError} if the request fails
-   */
-  async list(workspaceId, query) {
-    const { data } = await this.#api.GET(
-      "/workspaces/{workspace_id}/activities/",
-      {
-        params: { path: { workspaceId }, query }
-      }
-    );
-    return data;
-  }
-};
-
-// src/services/annotations.ts
-var AnnotationsService = class {
-  #api;
-  constructor(api) {
-    this.#api = api;
-  }
-  /**
-   * 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
-   * @throws {ApiError} if the request fails
-   */
-  async list(fileId, query) {
-    const { data } = await this.#api.GET("/files/{file_id}/annotations/", {
-      params: { path: { fileId }, query }
-    });
-    return data;
-  }
-  /**
-   * Get annotation details by ID
-   * @param annotationId - Annotation ID
-   * @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}", {
-      params: { path: { annotationId } }
-    });
-    return data;
-  }
-  /**
-   * 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
-   */
-  async create(fileId, annotation) {
-    const { data } = await this.#api.POST("/files/{file_id}/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 update(annotationId, updates) {
-    const { data } = await this.#api.PATCH("/annotations/{annotation_id}", {
-      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 delete(annotationId) {
-    await this.#api.DELETE("/annotations/{annotation_id}", {
-      params: { path: { annotationId } }
-    });
-  }
-};
-
-// src/services/api-tokens.ts
-var ApiTokensService = 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
-   * @throws {ApiError} if the request fails
-   */
-  async list(options) {
-    const { data } = await this.#api.GET("/api-tokens/", {
-      params: { query: options }
-    });
-    return data;
-  }
-  /**
-   * Get a specific API token by access token
-   * @param accessToken - The access 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 } }
-      }
-    );
-    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)
-   * @throws {ApiError} if the request fails
-   */
-  async create(token) {
-    const { data } = await this.#api.POST("/api-tokens/", {
-      body: token
-    });
-    return data;
-  }
-  /**
-   * Update an existing API token
-   * @param accessToken - The access 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
-      }
-    );
-    return data;
-  }
-  /**
-   * Revoke an API token
-   * @param accessToken - The access 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 } }
-      }
-    );
-  }
-};
-
-// src/services/auth.ts
-var AuthService = class {
-  #api;
-  constructor(api) {
-    this.#api = api;
-  }
-  /**
-   * 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
-   */
-  async login(credentials) {
-    const { data } = await this.#api.POST("/auth/login", {
-      body: credentials
-    });
-    return data;
-  }
-  /**
-   * Sign up a new account
-   * @param details - Signup details
-   * @returns Promise that resolves with the auth response containing access token
-   * @throws {ApiError} if the request fails
-   */
-  async signup(details) {
-    const { data } = await this.#api.POST("/auth/signup", {
-      body: details
-    });
-    return data;
-  }
-};
-
-// src/services/comments.ts
-var CommentsService = class {
-  #api;
-  constructor(api) {
-    this.#api = api;
-  }
-  /**
-   * 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
-   * @throws {ApiError} if the request fails
-   */
-  async list(fileId, query) {
-    const { data } = await this.#api.GET("/files/{file_id}/comments", {
-      params: { path: { fileId }, query }
-    });
-    return data;
-  }
-  /**
-   * 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
-   */
-  async create(fileId, comment) {
-    const { data } = await this.#api.POST("/files/{file_id}/comments", {
-      params: { path: { fileId } },
-      body: comment
-    });
-    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 } }
-    });
-  }
-};
-
-// src/services/documents.ts
-var DocumentsService = class {
-  #api;
-  constructor(api) {
-    this.#api = api;
-  }
-  /**
-   * 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
-   * @throws {ApiError} if the request fails
-   */
-  async list(workspaceId, query) {
-    const { data } = await this.#api.GET(
-      "/workspaces/{workspace_id}/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 get(documentId) {
-    const { data } = await this.#api.GET("/documents/{document_id}", {
-      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 create(workspaceId, document) {
-    const { data } = await this.#api.POST(
-      "/workspaces/{workspace_id}/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 update(documentId, updates) {
-    const { data } = await this.#api.PATCH("/documents/{document_id}", {
-      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 delete(documentId) {
-    await this.#api.DELETE("/documents/{document_id}", {
-      params: { path: { documentId } }
-    });
-  }
-};
-
-// src/services/files.ts
-var FilesService = class {
-  #api;
-  constructor(api) {
-    this.#api = api;
-  }
-  /**
-   * 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
-   * @throws {ApiError} if the request fails
-   */
-  async list(workspaceId, query) {
-    const { data } = await this.#api.GET("/workspaces/{workspace_id}/files/", {
-      params: { path: { workspaceId }, query }
-    });
-    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}", {
-      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 update(fileId, updates) {
-    const { data } = await this.#api.PATCH("/files/{file_id}", {
-      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 delete(fileId) {
-    await this.#api.DELETE("/files/{file_id}", {
-      params: { path: { fileId } }
-    });
-  }
-  /**
-   * Download multiple files
-   * @param workspaceId - Workspace ID
-   * @param request - Download request with file IDs
-   * @returns Promise that resolves with the download response
-   * @throws {ApiError} if the request fails
-   */
-  async downloadMultiple(workspaceId, request) {
-    const { response } = await this.#api.POST(
-      "/workspaces/{workspace_id}/files/download",
-      {
-        params: { path: { workspaceId } },
-        body: request,
-        parseAs: "stream"
-      }
-    );
-    return response;
-  }
-  /**
-   * Download files as an archive
-   * @param workspaceId - Workspace ID
-   * @param request - Archive download request
-   * @returns Promise that resolves with the archive response
-   * @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;
-  }
-};
-
-// src/services/integrations.ts
-var IntegrationsService = class {
-  #api;
-  constructor(api) {
-    this.#api = api;
-  }
-  /**
-   * 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
-   * @throws {ApiError} if the request fails
-   */
-  async list(workspaceId, query) {
-    const { data } = await this.#api.GET(
-      "/workspaces/{workspace_id}/integrations/",
-      {
-        params: { path: { workspaceId }, query }
-      }
-    );
-    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 get(integrationId) {
-    const { data } = await this.#api.GET("/integrations/{integration_id}/", {
-      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 create(workspaceId, integration) {
-    const { data } = await this.#api.POST(
-      "/workspaces/{workspace_id}/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 update(integrationId, updates) {
-    const { data } = await this.#api.PUT("/integrations/{integration_id}/", {
-      params: { path: { integrationId } },
-      body: updates
-    });
-    return data;
-  }
-  /**
-   * 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
-   */
-  async updateCredentials(integrationId, credentials) {
-    const { data } = await this.#api.PATCH(
-      "/integrations/{integration_id}/credentials/",
-      {
-        params: { path: { integrationId } },
-        body: credentials
-      }
-    );
-    return data;
-  }
-  /**
-   * Delete an integration
-   * @param integrationId - Integration ID
-   * @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}/", {
-      params: { path: { integrationId } }
-    });
-  }
-};
-
-// src/services/invites.ts
-var InvitesService = class {
-  #api;
-  constructor(api) {
-    this.#api = api;
-  }
-  /**
-   * 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
-   * @throws {ApiError} if the request fails
-   */
-  async list(workspaceId, query) {
-    const { data } = await this.#api.GET(
-      "/workspaces/{workspace_id}/invites/",
-      {
-        params: { path: { workspaceId }, query }
-      }
-    );
-    return data;
-  }
-  /**
-   * 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
-   */
-  async send(workspaceId, invite) {
-    const { data } = await this.#api.POST(
-      "/workspaces/{workspace_id}/invites/",
-      {
-        params: { path: { workspaceId } },
-        body: invite
-      }
-    );
-    return data;
-  }
-  /**
-   * Cancel a pending invitation
-   * @param inviteId - Invite ID
-   * @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}/", {
-      params: { path: { inviteId } }
-    });
-  }
-  /**
-   * 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
-   */
-  async reply(inviteId, reply) {
-    const { data } = await this.#api.PATCH("/invites/{invite_id}/reply/", {
-      params: { path: { inviteId } },
-      body: reply
-    });
-    return data;
-  }
-  /**
-   * 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
-   */
-  async generateCode(workspaceId, options) {
-    const { data } = await this.#api.POST(
-      "/workspaces/{workspace_id}/invites/code/",
-      {
-        params: { path: { workspaceId } },
-        body: options
-      }
-    );
-    return data;
-  }
-  /**
-   * Join a workspace using an invite code
-   * @param inviteCode - The invite code
-   * @returns Promise that resolves with the member details
-   * @throws {ApiError} if the request fails
-   */
-  async joinWithCode(inviteCode) {
-    const { data } = await this.#api.POST("/invites/{invite_code}/join/", {
-      params: { path: { inviteCode } }
-    });
-    return data;
-  }
-};
-
-// src/services/members.ts
-var MembersService = class {
-  #api;
-  constructor(api) {
-    this.#api = api;
-  }
-  /**
-   * 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
-   * @throws {ApiError} if the request fails
-   */
-  async list(workspaceId, query) {
-    const { data } = await this.#api.GET(
-      "/workspaces/{workspace_id}/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 get(workspaceId, accountId) {
-    const { data } = await this.#api.GET(
-      "/workspaces/{workspace_id}/members/{account_id}/",
-      {
-        params: { path: { workspaceId, accountId } }
-      }
-    );
-    return data;
-  }
-  /**
-   * Update a member's role
-   * @param workspaceId - Workspace ID
-   * @param accountId - Account ID
-   * @param role - New role for the member
-   * @returns Promise that resolves with the updated member
-   * @throws {ApiError} if the request fails
-   */
-  async updateRole(workspaceId, accountId, role) {
-    const { data } = await this.#api.PATCH(
-      "/workspaces/{workspace_id}/members/{account_id}/role",
-      {
-        params: { path: { workspaceId, accountId } },
-        body: role
-      }
-    );
-    return data;
-  }
-  /**
-   * 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
-   */
-  async remove(workspaceId, accountId) {
-    await this.#api.DELETE("/workspaces/{workspace_id}/members/{account_id}/", {
-      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 leave(workspaceId) {
-    await this.#api.POST("/workspaces/{workspace_id}/members/leave", {
-      params: { path: { workspaceId } }
-    });
-  }
-};
-
-// src/services/notifications.ts
-var NotificationsService = 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
-   * @throws {ApiError} if the request fails
-   */
-  async list(query) {
-    const { data } = await this.#api.GET("/notifications/", {
-      params: { query }
-    });
-    return data;
-  }
-};
-
-// src/services/runs.ts
-var RunsService = class {
-  #api;
-  constructor(api) {
-    this.#api = api;
-  }
-  /**
-   * 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
-   * @throws {ApiError} if the request fails
-   */
-  async list(workspaceId, query) {
-    const { data } = await this.#api.GET("/workspaces/{workspace_id}/runs/", {
-      params: { path: { workspaceId }, query }
-    });
-    return data;
-  }
-  /**
-   * 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
-   */
-  async get(runId) {
-    const { data } = await this.#api.GET("/runs/{run_id}", {
-      params: { path: { runId } }
-    });
-    return data;
-  }
-};
-
-// src/services/status.ts
-var StatusService = class {
-  #api;
-  constructor(api) {
-    this.#api = api;
-  }
-  /**
-   * Check the health status of the API
-   * @param options - Health check options
-   * @returns Promise that resolves with the API health status
-   */
-  async health(options) {
-    const { data, error } = await this.#api.GET("/health", {
-      params: { path: { version: "v1" } },
-      body: options ?? {}
-    });
-    return data ?? error;
-  }
-};
-
-// src/services/webhooks.ts
-var WebhooksService = class {
-  #api;
-  constructor(api) {
-    this.#api = api;
-  }
-  /**
-   * List all webhooks in a workspace
-   * @param workspaceId - Workspace ID
-   * @returns Promise that resolves with the list of webhooks
-   * @throws {ApiError} if the request fails
-   */
-  async list(workspaceId) {
-    const { data } = await this.#api.GET(
-      "/workspaces/{workspace_id}/webhooks/",
-      {
-        params: { path: { workspaceId } }
-      }
-    );
-    return data;
-  }
-  /**
-   * Get a specific webhook by ID
-   * @param webhookId - Webhook ID
-   * @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}/", {
-      params: { path: { webhookId } }
-    });
-    return data;
-  }
-  /**
-   * 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)
-   * @throws {ApiError} if the request fails
-   */
-  async create(workspaceId, webhook) {
-    const { data } = await this.#api.POST(
-      "/workspaces/{workspace_id}/webhooks/",
-      {
-        params: { path: { workspaceId } },
-        body: webhook
-      }
-    );
-    return data;
-  }
-  /**
-   * 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
-   */
-  async update(webhookId, updates) {
-    const { data } = await this.#api.PUT("/webhooks/{webhook_id}/", {
-      params: { path: { webhookId } },
-      body: updates
-    });
-    return data;
-  }
-  /**
-   * Delete a webhook
-   * @param webhookId - Webhook ID
-   * @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}/", {
-      params: { path: { webhookId } }
-    });
-  }
-};
-
-// src/services/workspaces.ts
-var WorkspacesService = 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
-   * @throws {ApiError} if the request fails
-   */
-  async list(query) {
-    const { data } = await this.#api.GET("/workspaces/", {
-      params: { query }
-    });
-    return data;
-  }
-  /**
-   * Get workspace details by ID
-   * @param workspaceId - Workspace ID
-   * @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}/", {
-      params: { path: { workspaceId } }
-    });
-    return data;
-  }
-  /**
-   * Create a new workspace
-   * @param workspace - Workspace creation request
-   * @returns Promise that resolves with the created workspace
-   * @throws {ApiError} if the request fails
-   */
-  async create(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 update(workspaceId, updates) {
-    const { data } = await this.#api.PATCH("/workspaces/{workspace_id}/", {
-      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 delete(workspaceId) {
-    await this.#api.DELETE("/workspaces/{workspace_id}/", {
-      params: { path: { workspaceId } }
-    });
-  }
-};
-
-// src/client.ts
-var Client = class _Client {
-  /**
-   * 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 {ConfigError} If the API token is invalid
-   *
-   * @example
-   * ```typescript
-   * const client = new Client({
-   *   apiToken: "your-api-token",
-   *   baseUrl: "https://custom.api.nvisy.com",
-   * });
-   * const account = await client.account.get();
-   * ```
-   */
-  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
-    };
-    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
-    });
-    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 {ConfigError} 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");
-    }
-    const trimmedToken = apiToken.trim();
-    if (trimmedToken.length < 10) {
-      throw ConfigError.invalidField(
-        "apiToken",
-        "must be at least 10 characters"
-      );
-    }
-    if (!/^[a-zA-Z0-9_-]+$/.test(trimmedToken)) {
-      throw ConfigError.invalidField("apiToken", "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 Client instance with the new token
-   * @throws {ConfigError} If the API token is invalid
-   *
-   * @example
-   * ```typescript
-   * const client = new Client({ apiToken: "original-token" });
-   * const newClient = client.withApiToken("new-token");
-   *
-   * // newClient uses the new token
-   * // client still uses the original token
-   * ```
-   */
-  withApiToken(apiToken) {
-    return new _Client({ ...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).
-   *
-   * @returns The AuthService instance
-   */
-  get auth() {
-    return new AuthService(this.#api);
-  }
-  /**
-   * Service for API status and health checks.
-   *
-   * @returns The StatusService instance
-   */
-  get status() {
-    return new StatusService(this.#api);
-  }
-  /**
-   * Service for managing the authenticated user's account.
-   *
-   * @returns The AccountService instance
-   */
-  get account() {
-    return new AccountService(this.#api);
-  }
-  /**
-   * Service for managing API tokens.
-   *
-   * @returns The ApiTokensService instance
-   */
-  get apiTokens() {
-    return new ApiTokensService(this.#api);
-  }
-  /**
-   * Service for managing file comments.
-   *
-   * @returns The CommentsService instance
-   */
-  get comments() {
-    return new CommentsService(this.#api);
-  }
-  /**
-   * Service for document operations.
-   *
-   * @returns The DocumentsService instance
-   */
-  get documents() {
-    return new DocumentsService(this.#api);
-  }
-  /**
-   * Service for file operations (upload, download, delete).
-   *
-   * @returns The FilesService instance
-   */
-  get files() {
-    return new FilesService(this.#api);
-  }
-  /**
-   * Service for managing integrations.
-   *
-   * @returns The IntegrationsService instance
-   */
-  get integrations() {
-    return new IntegrationsService(this.#api);
-  }
-  /**
-   * Service for managing workspace invitations.
-   *
-   * @returns The InvitesService instance
-   */
-  get invites() {
-    return new InvitesService(this.#api);
-  }
-  /**
-   * Service for managing workspace members.
-   *
-   * @returns The MembersService instance
-   */
-  get members() {
-    return new MembersService(this.#api);
-  }
-  /**
-   * Service for managing webhooks.
-   *
-   * @returns The WebhooksService instance
-   */
-  get webhooks() {
-    return new WebhooksService(this.#api);
-  }
-  /**
-   * Service for managing workspaces.
-   *
-   * @returns The WorkspacesService instance
-   */
-  get workspaces() {
-    return new WorkspacesService(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 };
-//# sourceMappingURL=index.js.map
+//#endregion
+export { DEFAULTS, Nvisy, NvisyApiError, NvisyError, VERSION };
 //# sourceMappingURL=index.js.map